1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2014, STMicroelectronics International N.V. 4 * Copyright (c) 2021, SumUp Services GmbH 5 */ 6 #include <config.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <string_ext.h> 10 #include <tee_api.h> 11 #include <tee_api_defines_extensions.h> 12 #include <tee_internal_api_extensions.h> 13 #include <utee_syscalls.h> 14 #include <utee_defines.h> 15 #include <util.h> 16 #include "tee_api_private.h" 17 18 struct __TEE_OperationHandle { 19 TEE_OperationInfo info; 20 TEE_ObjectHandle key1; 21 TEE_ObjectHandle key2; 22 uint32_t operationState;/* Operation state : INITIAL or ACTIVE */ 23 uint8_t *buffer; /* buffer to collect complete blocks */ 24 bool buffer_two_blocks; /* True if two blocks need to be buffered */ 25 size_t block_size; /* Block size of cipher */ 26 size_t buffer_offs; /* Offset in buffer */ 27 uint32_t state; /* Handle to state in TEE Core */ 28 }; 29 30 /* Cryptographic Operations API - Generic Operation Functions */ 31 32 TEE_Result TEE_AllocateOperation(TEE_OperationHandle *operation, 33 uint32_t algorithm, uint32_t mode, 34 uint32_t maxKeySize) 35 { 36 TEE_Result res; 37 TEE_OperationHandle op = TEE_HANDLE_NULL; 38 uint32_t handle_state = 0; 39 size_t block_size = 1; 40 uint32_t req_key_usage; 41 bool with_private_key = false; 42 bool buffer_two_blocks = false; 43 44 if (!operation) 45 TEE_Panic(0); 46 47 if (algorithm == TEE_ALG_AES_XTS || algorithm == TEE_ALG_SM2_KEP) 48 handle_state = TEE_HANDLE_FLAG_EXPECT_TWO_KEYS; 49 50 /* Check algorithm max key size */ 51 switch (algorithm) { 52 case TEE_ALG_DSA_SHA1: 53 if (maxKeySize < 512) 54 return TEE_ERROR_NOT_SUPPORTED; 55 if (maxKeySize > 1024) 56 return TEE_ERROR_NOT_SUPPORTED; 57 if (maxKeySize % 64 != 0) 58 return TEE_ERROR_NOT_SUPPORTED; 59 break; 60 61 case TEE_ALG_DSA_SHA224: 62 if (maxKeySize != 2048) 63 return TEE_ERROR_NOT_SUPPORTED; 64 break; 65 66 case TEE_ALG_DSA_SHA256: 67 if (maxKeySize != 2048 && maxKeySize != 3072) 68 return TEE_ERROR_NOT_SUPPORTED; 69 break; 70 71 case TEE_ALG_ECDSA_P192: 72 case TEE_ALG_ECDH_P192: 73 if (maxKeySize != 192) 74 return TEE_ERROR_NOT_SUPPORTED; 75 break; 76 77 case TEE_ALG_ECDSA_P224: 78 case TEE_ALG_ECDH_P224: 79 if (maxKeySize != 224) 80 return TEE_ERROR_NOT_SUPPORTED; 81 break; 82 83 case TEE_ALG_ECDSA_P256: 84 case TEE_ALG_ECDH_P256: 85 case TEE_ALG_SM2_PKE: 86 case TEE_ALG_SM2_DSA_SM3: 87 if (maxKeySize != 256) 88 return TEE_ERROR_NOT_SUPPORTED; 89 break; 90 91 case TEE_ALG_SM2_KEP: 92 /* Two 256-bit keys */ 93 if (maxKeySize != 512) 94 return TEE_ERROR_NOT_SUPPORTED; 95 break; 96 97 case TEE_ALG_ECDSA_P384: 98 case TEE_ALG_ECDH_P384: 99 if (maxKeySize != 384) 100 return TEE_ERROR_NOT_SUPPORTED; 101 break; 102 103 case TEE_ALG_ECDSA_P521: 104 case TEE_ALG_ECDH_P521: 105 if (maxKeySize != 521) 106 return TEE_ERROR_NOT_SUPPORTED; 107 break; 108 109 default: 110 break; 111 } 112 113 /* Check algorithm mode (and maxKeySize for digests) */ 114 switch (algorithm) { 115 case TEE_ALG_AES_CTS: 116 case TEE_ALG_AES_XTS: 117 buffer_two_blocks = true; 118 fallthrough; 119 case TEE_ALG_AES_ECB_NOPAD: 120 case TEE_ALG_AES_CBC_NOPAD: 121 case TEE_ALG_AES_CCM: 122 case TEE_ALG_DES_ECB_NOPAD: 123 case TEE_ALG_DES_CBC_NOPAD: 124 case TEE_ALG_DES3_ECB_NOPAD: 125 case TEE_ALG_DES3_CBC_NOPAD: 126 case TEE_ALG_SM4_ECB_NOPAD: 127 case TEE_ALG_SM4_CBC_NOPAD: 128 case TEE_ALG_SM4_CTR: 129 if (TEE_ALG_GET_MAIN_ALG(algorithm) == TEE_MAIN_ALGO_AES) 130 block_size = TEE_AES_BLOCK_SIZE; 131 else if (TEE_ALG_GET_MAIN_ALG(algorithm) == TEE_MAIN_ALGO_SM4) 132 block_size = TEE_SM4_BLOCK_SIZE; 133 else 134 block_size = TEE_DES_BLOCK_SIZE; 135 fallthrough; 136 case TEE_ALG_AES_CTR: 137 case TEE_ALG_AES_GCM: 138 if (mode == TEE_MODE_ENCRYPT) 139 req_key_usage = TEE_USAGE_ENCRYPT; 140 else if (mode == TEE_MODE_DECRYPT) 141 req_key_usage = TEE_USAGE_DECRYPT; 142 else 143 return TEE_ERROR_NOT_SUPPORTED; 144 break; 145 146 #if defined(CFG_CRYPTO_RSASSA_NA1) 147 case TEE_ALG_RSASSA_PKCS1_V1_5: 148 #endif 149 case TEE_ALG_RSASSA_PKCS1_V1_5_MD5: 150 case TEE_ALG_RSASSA_PKCS1_V1_5_SHA1: 151 case TEE_ALG_RSASSA_PKCS1_V1_5_SHA224: 152 case TEE_ALG_RSASSA_PKCS1_V1_5_SHA256: 153 case TEE_ALG_RSASSA_PKCS1_V1_5_SHA384: 154 case TEE_ALG_RSASSA_PKCS1_V1_5_SHA512: 155 case TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA1: 156 case TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA224: 157 case TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA256: 158 case TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA384: 159 case TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA512: 160 case TEE_ALG_DSA_SHA1: 161 case TEE_ALG_DSA_SHA224: 162 case TEE_ALG_DSA_SHA256: 163 case TEE_ALG_ECDSA_P192: 164 case TEE_ALG_ECDSA_P224: 165 case TEE_ALG_ECDSA_P256: 166 case TEE_ALG_ECDSA_P384: 167 case TEE_ALG_ECDSA_P521: 168 case TEE_ALG_SM2_DSA_SM3: 169 if (mode == TEE_MODE_SIGN) { 170 with_private_key = true; 171 req_key_usage = TEE_USAGE_SIGN; 172 } else if (mode == TEE_MODE_VERIFY) { 173 req_key_usage = TEE_USAGE_VERIFY; 174 } else { 175 return TEE_ERROR_NOT_SUPPORTED; 176 } 177 break; 178 179 case TEE_ALG_RSAES_PKCS1_V1_5: 180 case TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA1: 181 case TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA224: 182 case TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA256: 183 case TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA384: 184 case TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA512: 185 case TEE_ALG_SM2_PKE: 186 if (mode == TEE_MODE_ENCRYPT) { 187 req_key_usage = TEE_USAGE_ENCRYPT; 188 } else if (mode == TEE_MODE_DECRYPT) { 189 with_private_key = true; 190 req_key_usage = TEE_USAGE_DECRYPT; 191 } else { 192 return TEE_ERROR_NOT_SUPPORTED; 193 } 194 break; 195 196 case TEE_ALG_RSA_NOPAD: 197 if (mode == TEE_MODE_ENCRYPT) { 198 req_key_usage = TEE_USAGE_ENCRYPT | TEE_USAGE_VERIFY; 199 } else if (mode == TEE_MODE_DECRYPT) { 200 with_private_key = true; 201 req_key_usage = TEE_USAGE_DECRYPT | TEE_USAGE_SIGN; 202 } else { 203 return TEE_ERROR_NOT_SUPPORTED; 204 } 205 break; 206 207 case TEE_ALG_DH_DERIVE_SHARED_SECRET: 208 case TEE_ALG_ECDH_P192: 209 case TEE_ALG_ECDH_P224: 210 case TEE_ALG_ECDH_P256: 211 case TEE_ALG_ECDH_P384: 212 case TEE_ALG_ECDH_P521: 213 case TEE_ALG_HKDF_MD5_DERIVE_KEY: 214 case TEE_ALG_HKDF_SHA1_DERIVE_KEY: 215 case TEE_ALG_HKDF_SHA224_DERIVE_KEY: 216 case TEE_ALG_HKDF_SHA256_DERIVE_KEY: 217 case TEE_ALG_HKDF_SHA384_DERIVE_KEY: 218 case TEE_ALG_HKDF_SHA512_DERIVE_KEY: 219 case TEE_ALG_CONCAT_KDF_SHA1_DERIVE_KEY: 220 case TEE_ALG_CONCAT_KDF_SHA224_DERIVE_KEY: 221 case TEE_ALG_CONCAT_KDF_SHA256_DERIVE_KEY: 222 case TEE_ALG_CONCAT_KDF_SHA384_DERIVE_KEY: 223 case TEE_ALG_CONCAT_KDF_SHA512_DERIVE_KEY: 224 case TEE_ALG_PBKDF2_HMAC_SHA1_DERIVE_KEY: 225 case TEE_ALG_SM2_KEP: 226 if (mode != TEE_MODE_DERIVE) 227 return TEE_ERROR_NOT_SUPPORTED; 228 with_private_key = true; 229 req_key_usage = TEE_USAGE_DERIVE; 230 break; 231 232 case TEE_ALG_MD5: 233 case TEE_ALG_SHA1: 234 case TEE_ALG_SHA224: 235 case TEE_ALG_SHA256: 236 case TEE_ALG_SHA384: 237 case TEE_ALG_SHA512: 238 case TEE_ALG_SM3: 239 if (mode != TEE_MODE_DIGEST) 240 return TEE_ERROR_NOT_SUPPORTED; 241 if (maxKeySize) 242 return TEE_ERROR_NOT_SUPPORTED; 243 /* v1.1: flags always set for digest operations */ 244 handle_state |= TEE_HANDLE_FLAG_KEY_SET; 245 req_key_usage = 0; 246 break; 247 248 case TEE_ALG_DES_CBC_MAC_NOPAD: 249 case TEE_ALG_AES_CBC_MAC_NOPAD: 250 case TEE_ALG_AES_CBC_MAC_PKCS5: 251 case TEE_ALG_AES_CMAC: 252 case TEE_ALG_DES_CBC_MAC_PKCS5: 253 case TEE_ALG_DES3_CBC_MAC_NOPAD: 254 case TEE_ALG_DES3_CBC_MAC_PKCS5: 255 case TEE_ALG_DES3_CMAC: 256 case TEE_ALG_HMAC_MD5: 257 case TEE_ALG_HMAC_SHA1: 258 case TEE_ALG_HMAC_SHA224: 259 case TEE_ALG_HMAC_SHA256: 260 case TEE_ALG_HMAC_SHA384: 261 case TEE_ALG_HMAC_SHA512: 262 case TEE_ALG_HMAC_SM3: 263 if (mode != TEE_MODE_MAC) 264 return TEE_ERROR_NOT_SUPPORTED; 265 req_key_usage = TEE_USAGE_MAC; 266 break; 267 268 default: 269 return TEE_ERROR_NOT_SUPPORTED; 270 } 271 272 op = TEE_Malloc(sizeof(*op), TEE_MALLOC_FILL_ZERO); 273 if (!op) 274 return TEE_ERROR_OUT_OF_MEMORY; 275 276 op->info.algorithm = algorithm; 277 op->info.operationClass = TEE_ALG_GET_CLASS(algorithm); 278 #ifdef CFG_CRYPTO_RSASSA_NA1 279 if (algorithm == TEE_ALG_RSASSA_PKCS1_V1_5) 280 op->info.operationClass = TEE_OPERATION_ASYMMETRIC_SIGNATURE; 281 #endif 282 op->info.mode = mode; 283 op->info.digestLength = TEE_ALG_GET_DIGEST_SIZE(algorithm); 284 op->info.maxKeySize = maxKeySize; 285 op->info.requiredKeyUsage = req_key_usage; 286 op->info.handleState = handle_state; 287 288 if (block_size > 1) { 289 size_t buffer_size = block_size; 290 291 if (buffer_two_blocks) 292 buffer_size *= 2; 293 294 op->buffer = TEE_Malloc(buffer_size, 295 TEE_USER_MEM_HINT_NO_FILL_ZERO); 296 if (op->buffer == NULL) { 297 res = TEE_ERROR_OUT_OF_MEMORY; 298 goto out; 299 } 300 } 301 op->block_size = block_size; 302 op->buffer_two_blocks = buffer_two_blocks; 303 304 if (TEE_ALG_GET_CLASS(algorithm) != TEE_OPERATION_DIGEST) { 305 uint32_t mks = maxKeySize; 306 TEE_ObjectType key_type = TEE_ALG_GET_KEY_TYPE(algorithm, 307 with_private_key); 308 309 /* 310 * If two keys are expected the max key size is the sum of 311 * the size of both keys. 312 */ 313 if (op->info.handleState & TEE_HANDLE_FLAG_EXPECT_TWO_KEYS) 314 mks /= 2; 315 316 res = TEE_AllocateTransientObject(key_type, mks, &op->key1); 317 if (res != TEE_SUCCESS) 318 goto out; 319 320 if (op->info.handleState & TEE_HANDLE_FLAG_EXPECT_TWO_KEYS) { 321 res = TEE_AllocateTransientObject(key_type, mks, 322 &op->key2); 323 if (res != TEE_SUCCESS) 324 goto out; 325 } 326 } 327 328 res = _utee_cryp_state_alloc(algorithm, mode, (unsigned long)op->key1, 329 (unsigned long)op->key2, &op->state); 330 if (res != TEE_SUCCESS) 331 goto out; 332 333 /* 334 * Initialize digest operations 335 * Other multi-stage operations initialized w/ TEE_xxxInit functions 336 * Non-applicable on asymmetric operations 337 */ 338 if (TEE_ALG_GET_CLASS(algorithm) == TEE_OPERATION_DIGEST) { 339 res = _utee_hash_init(op->state, NULL, 0); 340 if (res != TEE_SUCCESS) 341 goto out; 342 /* v1.1: flags always set for digest operations */ 343 op->info.handleState |= TEE_HANDLE_FLAG_INITIALIZED; 344 } 345 346 op->operationState = TEE_OPERATION_STATE_INITIAL; 347 348 *operation = op; 349 350 out: 351 if (res != TEE_SUCCESS) { 352 if (res != TEE_ERROR_OUT_OF_MEMORY && 353 res != TEE_ERROR_NOT_SUPPORTED) 354 TEE_Panic(res); 355 if (op) { 356 if (op->state) { 357 TEE_FreeOperation(op); 358 } else { 359 TEE_Free(op->buffer); 360 TEE_FreeTransientObject(op->key1); 361 TEE_FreeTransientObject(op->key2); 362 TEE_Free(op); 363 } 364 } 365 } 366 367 return res; 368 } 369 370 void TEE_FreeOperation(TEE_OperationHandle operation) 371 { 372 TEE_Result res; 373 374 if (operation == TEE_HANDLE_NULL) 375 TEE_Panic(0); 376 377 /* 378 * Note that keys should not be freed here, since they are 379 * claimed by the operation they will be freed by 380 * utee_cryp_state_free(). 381 */ 382 res = _utee_cryp_state_free(operation->state); 383 if (res != TEE_SUCCESS) 384 TEE_Panic(res); 385 386 TEE_Free(operation->buffer); 387 TEE_Free(operation); 388 } 389 390 void TEE_GetOperationInfo(TEE_OperationHandle operation, 391 TEE_OperationInfo *operationInfo) 392 { 393 if (operation == TEE_HANDLE_NULL) 394 TEE_Panic(0); 395 396 __utee_check_out_annotation(operationInfo, sizeof(*operationInfo)); 397 398 *operationInfo = operation->info; 399 if (operationInfo->handleState & TEE_HANDLE_FLAG_EXPECT_TWO_KEYS) { 400 operationInfo->keySize = 0; 401 operationInfo->requiredKeyUsage = 0; 402 } 403 } 404 405 TEE_Result TEE_GetOperationInfoMultiple(TEE_OperationHandle op, 406 TEE_OperationInfoMultiple *op_info, 407 uint32_t *size) 408 { 409 TEE_Result res = TEE_SUCCESS; 410 TEE_ObjectInfo kinfo = { }; 411 size_t max_key_count = 0; 412 bool two_keys = false; 413 414 if (op == TEE_HANDLE_NULL) { 415 res = TEE_ERROR_BAD_PARAMETERS; 416 goto out; 417 } 418 419 __utee_check_outbuf_annotation(op_info, size); 420 421 if (*size < sizeof(*op_info)) { 422 res = TEE_ERROR_BAD_PARAMETERS; 423 goto out; 424 } 425 max_key_count = (*size - sizeof(*op_info)) / 426 sizeof(TEE_OperationInfoKey); 427 428 TEE_MemFill(op_info, 0, *size); 429 430 /* Two keys flag (TEE_ALG_AES_XTS only) */ 431 two_keys = op->info.handleState & TEE_HANDLE_FLAG_EXPECT_TWO_KEYS; 432 433 if (op->info.mode == TEE_MODE_DIGEST) { 434 op_info->numberOfKeys = 0; 435 } else if (!two_keys) { 436 if (max_key_count < 1) { 437 res = TEE_ERROR_SHORT_BUFFER; 438 goto out; 439 } 440 441 res = TEE_GetObjectInfo1(op->key1, &kinfo); 442 /* Key1 is not a valid handle, "can't happen". */ 443 if (res) 444 goto out; 445 446 op_info->keyInformation[0].keySize = kinfo.keySize; 447 op_info->keyInformation[0].requiredKeyUsage = 448 op->info.requiredKeyUsage; 449 op_info->numberOfKeys = 1; 450 } else { 451 if (max_key_count < 2) { 452 res = TEE_ERROR_SHORT_BUFFER; 453 goto out; 454 } 455 456 res = TEE_GetObjectInfo1(op->key1, &kinfo); 457 /* Key1 is not a valid handle, "can't happen". */ 458 if (res) 459 goto out; 460 461 op_info->keyInformation[0].keySize = kinfo.keySize; 462 op_info->keyInformation[0].requiredKeyUsage = 463 op->info.requiredKeyUsage; 464 465 res = TEE_GetObjectInfo1(op->key2, &kinfo); 466 /* Key2 is not a valid handle, "can't happen". */ 467 if (res) 468 goto out; 469 470 op_info->keyInformation[1].keySize = kinfo.keySize; 471 op_info->keyInformation[1].requiredKeyUsage = 472 op->info.requiredKeyUsage; 473 474 op_info->numberOfKeys = 2; 475 } 476 477 op_info->algorithm = op->info.algorithm; 478 op_info->operationClass = op->info.operationClass; 479 op_info->mode = op->info.mode; 480 op_info->digestLength = op->info.digestLength; 481 op_info->maxKeySize = op->info.maxKeySize; 482 op_info->handleState = op->info.handleState; 483 op_info->operationState = op->operationState; 484 485 out: 486 if (res != TEE_SUCCESS && 487 res != TEE_ERROR_SHORT_BUFFER) 488 TEE_Panic(res); 489 490 return res; 491 } 492 493 void TEE_ResetOperation(TEE_OperationHandle operation) 494 { 495 TEE_Result res; 496 497 if (operation == TEE_HANDLE_NULL) 498 TEE_Panic(0); 499 500 if (!(operation->info.handleState & TEE_HANDLE_FLAG_KEY_SET)) 501 TEE_Panic(0); 502 503 operation->operationState = TEE_OPERATION_STATE_INITIAL; 504 505 if (operation->info.operationClass == TEE_OPERATION_DIGEST) { 506 res = _utee_hash_init(operation->state, NULL, 0); 507 if (res != TEE_SUCCESS) 508 TEE_Panic(res); 509 operation->info.handleState |= TEE_HANDLE_FLAG_INITIALIZED; 510 } else { 511 operation->info.handleState &= ~TEE_HANDLE_FLAG_INITIALIZED; 512 } 513 } 514 515 TEE_Result TEE_SetOperationKey(TEE_OperationHandle operation, 516 TEE_ObjectHandle key) 517 { 518 TEE_Result res; 519 uint32_t key_size = 0; 520 TEE_ObjectInfo key_info; 521 522 if (operation == TEE_HANDLE_NULL) { 523 res = TEE_ERROR_BAD_PARAMETERS; 524 goto out; 525 } 526 527 if (operation->operationState != TEE_OPERATION_STATE_INITIAL) { 528 res = TEE_ERROR_BAD_PARAMETERS; 529 goto out; 530 } 531 532 if (key == TEE_HANDLE_NULL) { 533 /* Operation key cleared */ 534 TEE_ResetTransientObject(operation->key1); 535 operation->info.handleState &= ~TEE_HANDLE_FLAG_KEY_SET; 536 return TEE_SUCCESS; 537 } 538 539 /* No key for digest operation */ 540 if (operation->info.operationClass == TEE_OPERATION_DIGEST) { 541 res = TEE_ERROR_BAD_PARAMETERS; 542 goto out; 543 } 544 545 /* Two keys flag not expected (TEE_ALG_AES_XTS excluded) */ 546 if ((operation->info.handleState & TEE_HANDLE_FLAG_EXPECT_TWO_KEYS) != 547 0) { 548 res = TEE_ERROR_BAD_PARAMETERS; 549 goto out; 550 } 551 552 res = TEE_GetObjectInfo1(key, &key_info); 553 /* Key is not a valid handle */ 554 if (res != TEE_SUCCESS) 555 goto out; 556 557 /* Supplied key has to meet required usage */ 558 if ((key_info.objectUsage & operation->info.requiredKeyUsage) != 559 operation->info.requiredKeyUsage) { 560 res = TEE_ERROR_BAD_PARAMETERS; 561 goto out; 562 } 563 564 if (operation->info.maxKeySize < key_info.keySize) { 565 res = TEE_ERROR_BAD_PARAMETERS; 566 goto out; 567 } 568 569 key_size = key_info.keySize; 570 571 TEE_ResetTransientObject(operation->key1); 572 operation->info.handleState &= ~TEE_HANDLE_FLAG_KEY_SET; 573 574 res = TEE_CopyObjectAttributes1(operation->key1, key); 575 if (res != TEE_SUCCESS) 576 goto out; 577 578 operation->info.handleState |= TEE_HANDLE_FLAG_KEY_SET; 579 580 operation->info.keySize = key_size; 581 582 out: 583 if (res != TEE_SUCCESS && 584 res != TEE_ERROR_CORRUPT_OBJECT && 585 res != TEE_ERROR_STORAGE_NOT_AVAILABLE) 586 TEE_Panic(res); 587 588 return res; 589 } 590 591 TEE_Result TEE_SetOperationKey2(TEE_OperationHandle operation, 592 TEE_ObjectHandle key1, TEE_ObjectHandle key2) 593 { 594 TEE_Result res; 595 uint32_t key_size = 0; 596 TEE_ObjectInfo key_info1; 597 TEE_ObjectInfo key_info2; 598 599 if (operation == TEE_HANDLE_NULL) { 600 res = TEE_ERROR_BAD_PARAMETERS; 601 goto out; 602 } 603 604 if (operation->operationState != TEE_OPERATION_STATE_INITIAL) { 605 res = TEE_ERROR_BAD_PARAMETERS; 606 goto out; 607 } 608 609 /* 610 * Key1/Key2 and/or are not initialized and 611 * Either both keys are NULL or both are not NULL 612 */ 613 if (!key1 && !key2) { 614 /* Clear the keys */ 615 TEE_ResetTransientObject(operation->key1); 616 TEE_ResetTransientObject(operation->key2); 617 operation->info.handleState &= ~TEE_HANDLE_FLAG_KEY_SET; 618 return TEE_SUCCESS; 619 } else if (!key1 || !key2) { 620 /* Both keys are obviously not valid. */ 621 res = TEE_ERROR_BAD_PARAMETERS; 622 goto out; 623 } 624 625 /* No key for digest operation */ 626 if (operation->info.operationClass == TEE_OPERATION_DIGEST) { 627 res = TEE_ERROR_BAD_PARAMETERS; 628 goto out; 629 } 630 631 /* Two keys flag expected (TEE_ALG_AES_XTS and TEE_ALG_SM2_KEP only) */ 632 if ((operation->info.handleState & TEE_HANDLE_FLAG_EXPECT_TWO_KEYS) == 633 0) { 634 res = TEE_ERROR_BAD_PARAMETERS; 635 goto out; 636 } 637 638 res = TEE_GetObjectInfo1(key1, &key_info1); 639 /* Key1 is not a valid handle */ 640 if (res != TEE_SUCCESS) 641 goto out; 642 643 /* Supplied key has to meet required usage */ 644 if ((key_info1.objectUsage & operation->info. 645 requiredKeyUsage) != operation->info.requiredKeyUsage) { 646 res = TEE_ERROR_BAD_PARAMETERS; 647 goto out; 648 } 649 650 res = TEE_GetObjectInfo1(key2, &key_info2); 651 /* Key2 is not a valid handle */ 652 if (res != TEE_SUCCESS) { 653 if (res == TEE_ERROR_CORRUPT_OBJECT) 654 res = TEE_ERROR_CORRUPT_OBJECT_2; 655 goto out; 656 } 657 658 /* Supplied key has to meet required usage */ 659 if ((key_info2.objectUsage & operation->info. 660 requiredKeyUsage) != operation->info.requiredKeyUsage) { 661 res = TEE_ERROR_BAD_PARAMETERS; 662 goto out; 663 } 664 665 /* 666 * All the multi key algorithm currently supported requires the keys to 667 * be of equal size. 668 */ 669 if (key_info1.keySize != key_info2.keySize) { 670 res = TEE_ERROR_BAD_PARAMETERS; 671 goto out; 672 673 } 674 675 if (operation->info.maxKeySize < key_info1.keySize) { 676 res = TEE_ERROR_BAD_PARAMETERS; 677 goto out; 678 } 679 680 /* 681 * Odd that only the size of one key should be reported while 682 * size of two key are used when allocating the operation. 683 */ 684 key_size = key_info1.keySize; 685 686 TEE_ResetTransientObject(operation->key1); 687 TEE_ResetTransientObject(operation->key2); 688 operation->info.handleState &= ~TEE_HANDLE_FLAG_KEY_SET; 689 690 res = TEE_CopyObjectAttributes1(operation->key1, key1); 691 if (res != TEE_SUCCESS) 692 goto out; 693 res = TEE_CopyObjectAttributes1(operation->key2, key2); 694 if (res != TEE_SUCCESS) { 695 if (res == TEE_ERROR_CORRUPT_OBJECT) 696 res = TEE_ERROR_CORRUPT_OBJECT_2; 697 goto out; 698 } 699 700 operation->info.handleState |= TEE_HANDLE_FLAG_KEY_SET; 701 702 operation->info.keySize = key_size; 703 704 out: 705 if (res != TEE_SUCCESS && 706 res != TEE_ERROR_CORRUPT_OBJECT && 707 res != TEE_ERROR_CORRUPT_OBJECT_2 && 708 res != TEE_ERROR_STORAGE_NOT_AVAILABLE && 709 res != TEE_ERROR_STORAGE_NOT_AVAILABLE_2) 710 TEE_Panic(res); 711 712 return res; 713 } 714 715 void TEE_CopyOperation(TEE_OperationHandle dst_op, TEE_OperationHandle src_op) 716 { 717 TEE_Result res; 718 719 if (dst_op == TEE_HANDLE_NULL || src_op == TEE_HANDLE_NULL) 720 TEE_Panic(0); 721 if (dst_op->info.algorithm != src_op->info.algorithm) 722 TEE_Panic(0); 723 if (dst_op->info.mode != src_op->info.mode) 724 TEE_Panic(0); 725 if (src_op->info.operationClass != TEE_OPERATION_DIGEST) { 726 TEE_ObjectHandle key1 = TEE_HANDLE_NULL; 727 TEE_ObjectHandle key2 = TEE_HANDLE_NULL; 728 729 if (src_op->info.handleState & TEE_HANDLE_FLAG_KEY_SET) { 730 key1 = src_op->key1; 731 key2 = src_op->key2; 732 } 733 734 if ((src_op->info.handleState & 735 TEE_HANDLE_FLAG_EXPECT_TWO_KEYS) == 0) { 736 TEE_SetOperationKey(dst_op, key1); 737 } else { 738 TEE_SetOperationKey2(dst_op, key1, key2); 739 } 740 } 741 dst_op->info.handleState = src_op->info.handleState; 742 dst_op->info.keySize = src_op->info.keySize; 743 dst_op->info.digestLength = src_op->info.digestLength; 744 dst_op->operationState = src_op->operationState; 745 746 if (dst_op->buffer_two_blocks != src_op->buffer_two_blocks || 747 dst_op->block_size != src_op->block_size) 748 TEE_Panic(0); 749 750 if (dst_op->buffer != NULL) { 751 if (src_op->buffer == NULL) 752 TEE_Panic(0); 753 754 memcpy(dst_op->buffer, src_op->buffer, src_op->buffer_offs); 755 dst_op->buffer_offs = src_op->buffer_offs; 756 } else if (src_op->buffer != NULL) { 757 TEE_Panic(0); 758 } 759 760 res = _utee_cryp_state_copy(dst_op->state, src_op->state); 761 if (res != TEE_SUCCESS) 762 TEE_Panic(res); 763 } 764 765 /* Cryptographic Operations API - Message Digest Functions */ 766 767 static void init_hash_operation(TEE_OperationHandle operation, const void *IV, 768 uint32_t IVLen) 769 { 770 TEE_Result res; 771 772 /* 773 * Note : IV and IVLen are never used in current implementation 774 * This is why coherent values of IV and IVLen are not checked 775 */ 776 res = _utee_hash_init(operation->state, IV, IVLen); 777 if (res != TEE_SUCCESS) 778 TEE_Panic(res); 779 operation->buffer_offs = 0; 780 operation->info.handleState |= TEE_HANDLE_FLAG_INITIALIZED; 781 } 782 783 void TEE_DigestUpdate(TEE_OperationHandle operation, 784 const void *chunk, uint32_t chunkSize) 785 { 786 TEE_Result res = TEE_ERROR_GENERIC; 787 788 if (operation == TEE_HANDLE_NULL || 789 operation->info.operationClass != TEE_OPERATION_DIGEST) 790 TEE_Panic(0); 791 792 operation->operationState = TEE_OPERATION_STATE_ACTIVE; 793 794 res = _utee_hash_update(operation->state, chunk, chunkSize); 795 if (res != TEE_SUCCESS) 796 TEE_Panic(res); 797 } 798 799 TEE_Result TEE_DigestDoFinal(TEE_OperationHandle operation, const void *chunk, 800 uint32_t chunkLen, void *hash, uint32_t *hashLen) 801 { 802 TEE_Result res; 803 uint64_t hl; 804 805 if ((operation == TEE_HANDLE_NULL) || 806 (!chunk && chunkLen) || 807 (operation->info.operationClass != TEE_OPERATION_DIGEST)) { 808 res = TEE_ERROR_BAD_PARAMETERS; 809 goto out; 810 } 811 __utee_check_inout_annotation(hashLen, sizeof(*hashLen)); 812 813 hl = *hashLen; 814 res = _utee_hash_final(operation->state, chunk, chunkLen, hash, &hl); 815 *hashLen = hl; 816 if (res != TEE_SUCCESS) 817 goto out; 818 819 /* Reset operation state */ 820 init_hash_operation(operation, NULL, 0); 821 822 operation->operationState = TEE_OPERATION_STATE_INITIAL; 823 824 out: 825 if (res != TEE_SUCCESS && 826 res != TEE_ERROR_SHORT_BUFFER) 827 TEE_Panic(res); 828 829 return res; 830 } 831 832 /* Cryptographic Operations API - Symmetric Cipher Functions */ 833 834 void TEE_CipherInit(TEE_OperationHandle operation, const void *IV, 835 uint32_t IVLen) 836 { 837 TEE_Result res; 838 839 if (operation == TEE_HANDLE_NULL) 840 TEE_Panic(0); 841 842 if (operation->info.operationClass != TEE_OPERATION_CIPHER) 843 TEE_Panic(0); 844 845 if (!(operation->info.handleState & TEE_HANDLE_FLAG_KEY_SET) || 846 !(operation->key1)) 847 TEE_Panic(0); 848 849 if (operation->operationState != TEE_OPERATION_STATE_INITIAL) 850 TEE_ResetOperation(operation); 851 852 if (IV && IVLen) { 853 if (operation->info.algorithm == TEE_ALG_AES_ECB_NOPAD || 854 operation->info.algorithm == TEE_ALG_DES_ECB_NOPAD || 855 operation->info.algorithm == TEE_ALG_DES3_ECB_NOPAD || 856 operation->info.algorithm == TEE_ALG_SM4_ECB_NOPAD) 857 TEE_Panic(0); 858 } 859 860 operation->operationState = TEE_OPERATION_STATE_ACTIVE; 861 862 res = _utee_cipher_init(operation->state, IV, IVLen); 863 if (res != TEE_SUCCESS) 864 TEE_Panic(res); 865 866 operation->buffer_offs = 0; 867 operation->info.handleState |= TEE_HANDLE_FLAG_INITIALIZED; 868 } 869 870 static TEE_Result tee_buffer_update( 871 TEE_OperationHandle op, 872 TEE_Result(*update_func)(unsigned long state, const void *src, 873 size_t slen, void *dst, uint64_t *dlen), 874 const void *src_data, size_t src_len, 875 void *dest_data, uint64_t *dest_len) 876 { 877 TEE_Result res; 878 const uint8_t *src = src_data; 879 size_t slen = src_len; 880 uint8_t *dst = dest_data; 881 size_t dlen = *dest_len; 882 size_t acc_dlen = 0; 883 uint64_t tmp_dlen; 884 size_t l; 885 size_t buffer_size; 886 size_t buffer_left; 887 888 if (!src) { 889 if (slen) 890 TEE_Panic(0); 891 goto out; 892 } 893 894 if (op->buffer_two_blocks) { 895 buffer_size = op->block_size * 2; 896 buffer_left = 1; 897 } else { 898 buffer_size = op->block_size; 899 buffer_left = 0; 900 } 901 902 if (op->buffer_offs > 0) { 903 /* Fill up complete block */ 904 if (op->buffer_offs < op->block_size) 905 l = MIN(slen, op->block_size - op->buffer_offs); 906 else 907 l = MIN(slen, buffer_size - op->buffer_offs); 908 memcpy(op->buffer + op->buffer_offs, src, l); 909 op->buffer_offs += l; 910 src += l; 911 slen -= l; 912 if ((op->buffer_offs % op->block_size) != 0) 913 goto out; /* Nothing left to do */ 914 } 915 916 /* If we can feed from buffer */ 917 if ((op->buffer_offs > 0) && 918 ((op->buffer_offs + slen) >= (buffer_size + buffer_left))) { 919 l = ROUNDUP(op->buffer_offs + slen - buffer_size, 920 op->block_size); 921 l = MIN(op->buffer_offs, l); 922 tmp_dlen = dlen; 923 res = update_func(op->state, op->buffer, l, dst, &tmp_dlen); 924 if (res != TEE_SUCCESS) 925 TEE_Panic(res); 926 dst += tmp_dlen; 927 dlen -= tmp_dlen; 928 acc_dlen += tmp_dlen; 929 op->buffer_offs -= l; 930 if (op->buffer_offs > 0) { 931 /* 932 * Slen is small enough to be contained in rest buffer. 933 */ 934 memcpy(op->buffer, op->buffer + l, buffer_size - l); 935 memcpy(op->buffer + op->buffer_offs, src, slen); 936 op->buffer_offs += slen; 937 goto out; /* Nothing left to do */ 938 } 939 } 940 941 if (slen >= (buffer_size + buffer_left)) { 942 /* Buffer is empty, feed as much as possible from src */ 943 if (op->info.algorithm == TEE_ALG_AES_CTS) 944 l = ROUNDUP(slen - buffer_size, op->block_size); 945 else 946 l = ROUNDUP(slen - buffer_size + 1, op->block_size); 947 948 tmp_dlen = dlen; 949 res = update_func(op->state, src, l, dst, &tmp_dlen); 950 if (res != TEE_SUCCESS) 951 TEE_Panic(res); 952 src += l; 953 slen -= l; 954 dst += tmp_dlen; 955 dlen -= tmp_dlen; 956 acc_dlen += tmp_dlen; 957 } 958 959 /* Slen is small enough to be contained in buffer. */ 960 memcpy(op->buffer + op->buffer_offs, src, slen); 961 op->buffer_offs += slen; 962 963 out: 964 *dest_len = acc_dlen; 965 return TEE_SUCCESS; 966 } 967 968 TEE_Result TEE_CipherUpdate(TEE_OperationHandle operation, const void *srcData, 969 uint32_t srcLen, void *destData, uint32_t *destLen) 970 { 971 TEE_Result res; 972 size_t req_dlen; 973 uint64_t dl; 974 975 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) { 976 res = TEE_ERROR_BAD_PARAMETERS; 977 goto out; 978 } 979 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 980 981 if (operation->info.operationClass != TEE_OPERATION_CIPHER) { 982 res = TEE_ERROR_BAD_PARAMETERS; 983 goto out; 984 } 985 986 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 987 res = TEE_ERROR_BAD_PARAMETERS; 988 goto out; 989 } 990 991 if (operation->operationState != TEE_OPERATION_STATE_ACTIVE) { 992 res = TEE_ERROR_BAD_PARAMETERS; 993 goto out; 994 } 995 996 if (!srcData && !srcLen) { 997 *destLen = 0; 998 res = TEE_SUCCESS; 999 goto out; 1000 } 1001 1002 /* Calculate required dlen */ 1003 if (operation->block_size > 1) { 1004 req_dlen = ((operation->buffer_offs + srcLen) / 1005 operation->block_size) * operation->block_size; 1006 } else { 1007 req_dlen = srcLen; 1008 } 1009 if (operation->buffer_two_blocks) { 1010 if (req_dlen > operation->block_size * 2) 1011 req_dlen -= operation->block_size * 2; 1012 else 1013 req_dlen = 0; 1014 } 1015 /* 1016 * Check that required destLen is big enough before starting to feed 1017 * data to the algorithm. Errors during feeding of data are fatal as we 1018 * can't restore sync with this API. 1019 */ 1020 if (*destLen < req_dlen) { 1021 *destLen = req_dlen; 1022 res = TEE_ERROR_SHORT_BUFFER; 1023 goto out; 1024 } 1025 1026 dl = *destLen; 1027 if (operation->block_size > 1) { 1028 res = tee_buffer_update(operation, _utee_cipher_update, srcData, 1029 srcLen, destData, &dl); 1030 } else { 1031 if (srcLen > 0) { 1032 res = _utee_cipher_update(operation->state, srcData, 1033 srcLen, destData, &dl); 1034 } else { 1035 res = TEE_SUCCESS; 1036 dl = 0; 1037 } 1038 } 1039 *destLen = dl; 1040 1041 out: 1042 if (res != TEE_SUCCESS && 1043 res != TEE_ERROR_SHORT_BUFFER) 1044 TEE_Panic(res); 1045 1046 return res; 1047 } 1048 1049 TEE_Result TEE_CipherDoFinal(TEE_OperationHandle operation, 1050 const void *srcData, uint32_t srcLen, 1051 void *destData, uint32_t *destLen) 1052 { 1053 TEE_Result res = TEE_SUCCESS; 1054 uint8_t *dst = destData; 1055 size_t acc_dlen = 0; 1056 uint64_t tmp_dlen = 0; 1057 size_t req_dlen = 0; 1058 1059 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) { 1060 res = TEE_ERROR_BAD_PARAMETERS; 1061 goto out; 1062 } 1063 if (destLen) 1064 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 1065 1066 if (operation->info.operationClass != TEE_OPERATION_CIPHER) { 1067 res = TEE_ERROR_BAD_PARAMETERS; 1068 goto out; 1069 } 1070 1071 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 1072 res = TEE_ERROR_BAD_PARAMETERS; 1073 goto out; 1074 } 1075 1076 if (operation->operationState != TEE_OPERATION_STATE_ACTIVE) { 1077 res = TEE_ERROR_BAD_PARAMETERS; 1078 goto out; 1079 } 1080 1081 /* 1082 * Check that the final block doesn't require padding for those 1083 * algorithms that requires client to supply padding. 1084 */ 1085 if (operation->info.algorithm == TEE_ALG_AES_ECB_NOPAD || 1086 operation->info.algorithm == TEE_ALG_AES_CBC_NOPAD || 1087 operation->info.algorithm == TEE_ALG_DES_ECB_NOPAD || 1088 operation->info.algorithm == TEE_ALG_DES_CBC_NOPAD || 1089 operation->info.algorithm == TEE_ALG_DES3_ECB_NOPAD || 1090 operation->info.algorithm == TEE_ALG_DES3_CBC_NOPAD || 1091 operation->info.algorithm == TEE_ALG_SM4_ECB_NOPAD || 1092 operation->info.algorithm == TEE_ALG_SM4_CBC_NOPAD) { 1093 if (((operation->buffer_offs + srcLen) % operation->block_size) 1094 != 0) { 1095 res = TEE_ERROR_BAD_PARAMETERS; 1096 goto out; 1097 } 1098 } 1099 1100 /* 1101 * Check that required destLen is big enough before starting to feed 1102 * data to the algorithm. Errors during feeding of data are fatal as we 1103 * can't restore sync with this API. 1104 */ 1105 if (operation->block_size > 1) { 1106 req_dlen = operation->buffer_offs + srcLen; 1107 } else { 1108 req_dlen = srcLen; 1109 } 1110 if (destLen) 1111 tmp_dlen = *destLen; 1112 if (tmp_dlen < req_dlen) { 1113 if (destLen) 1114 *destLen = req_dlen; 1115 res = TEE_ERROR_SHORT_BUFFER; 1116 goto out; 1117 } 1118 1119 if (operation->block_size > 1) { 1120 if (srcLen) { 1121 res = tee_buffer_update(operation, _utee_cipher_update, 1122 srcData, srcLen, dst, 1123 &tmp_dlen); 1124 if (res != TEE_SUCCESS) 1125 goto out; 1126 1127 dst += tmp_dlen; 1128 acc_dlen += tmp_dlen; 1129 1130 tmp_dlen = *destLen - acc_dlen; 1131 } 1132 res = _utee_cipher_final(operation->state, operation->buffer, 1133 operation->buffer_offs, dst, 1134 &tmp_dlen); 1135 } else { 1136 res = _utee_cipher_final(operation->state, srcData, srcLen, dst, 1137 &tmp_dlen); 1138 } 1139 if (res != TEE_SUCCESS) 1140 goto out; 1141 1142 acc_dlen += tmp_dlen; 1143 if (destLen) 1144 *destLen = acc_dlen; 1145 1146 operation->info.handleState &= ~TEE_HANDLE_FLAG_INITIALIZED; 1147 1148 operation->operationState = TEE_OPERATION_STATE_INITIAL; 1149 1150 out: 1151 if (res != TEE_SUCCESS && 1152 res != TEE_ERROR_SHORT_BUFFER) 1153 TEE_Panic(res); 1154 1155 return res; 1156 } 1157 1158 /* Cryptographic Operations API - MAC Functions */ 1159 1160 void TEE_MACInit(TEE_OperationHandle operation, const void *IV, uint32_t IVLen) 1161 { 1162 if (operation == TEE_HANDLE_NULL) 1163 TEE_Panic(0); 1164 1165 if (operation->info.operationClass != TEE_OPERATION_MAC) 1166 TEE_Panic(0); 1167 1168 if (!(operation->info.handleState & TEE_HANDLE_FLAG_KEY_SET) || 1169 !(operation->key1)) 1170 TEE_Panic(0); 1171 1172 if (operation->operationState != TEE_OPERATION_STATE_INITIAL) 1173 TEE_ResetOperation(operation); 1174 1175 operation->operationState = TEE_OPERATION_STATE_ACTIVE; 1176 1177 init_hash_operation(operation, IV, IVLen); 1178 } 1179 1180 void TEE_MACUpdate(TEE_OperationHandle operation, const void *chunk, 1181 uint32_t chunkSize) 1182 { 1183 TEE_Result res; 1184 1185 if (operation == TEE_HANDLE_NULL || (chunk == NULL && chunkSize != 0)) 1186 TEE_Panic(0); 1187 1188 if (operation->info.operationClass != TEE_OPERATION_MAC) 1189 TEE_Panic(0); 1190 1191 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) 1192 TEE_Panic(0); 1193 1194 if (operation->operationState != TEE_OPERATION_STATE_ACTIVE) 1195 TEE_Panic(0); 1196 1197 res = _utee_hash_update(operation->state, chunk, chunkSize); 1198 if (res != TEE_SUCCESS) 1199 TEE_Panic(res); 1200 } 1201 1202 TEE_Result TEE_MACComputeFinal(TEE_OperationHandle operation, 1203 const void *message, uint32_t messageLen, 1204 void *mac, uint32_t *macLen) 1205 { 1206 TEE_Result res; 1207 uint64_t ml; 1208 1209 if (operation == TEE_HANDLE_NULL || (!message && messageLen)) { 1210 res = TEE_ERROR_BAD_PARAMETERS; 1211 goto out; 1212 } 1213 __utee_check_inout_annotation(macLen, sizeof(*macLen)); 1214 1215 if (operation->info.operationClass != TEE_OPERATION_MAC) { 1216 res = TEE_ERROR_BAD_PARAMETERS; 1217 goto out; 1218 } 1219 1220 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 1221 res = TEE_ERROR_BAD_PARAMETERS; 1222 goto out; 1223 } 1224 1225 if (operation->operationState != TEE_OPERATION_STATE_ACTIVE) { 1226 res = TEE_ERROR_BAD_PARAMETERS; 1227 goto out; 1228 } 1229 1230 ml = *macLen; 1231 res = _utee_hash_final(operation->state, message, messageLen, mac, &ml); 1232 *macLen = ml; 1233 if (res != TEE_SUCCESS) 1234 goto out; 1235 1236 operation->info.handleState &= ~TEE_HANDLE_FLAG_INITIALIZED; 1237 1238 operation->operationState = TEE_OPERATION_STATE_INITIAL; 1239 1240 out: 1241 if (res != TEE_SUCCESS && 1242 res != TEE_ERROR_SHORT_BUFFER) 1243 TEE_Panic(res); 1244 1245 return res; 1246 } 1247 1248 TEE_Result TEE_MACCompareFinal(TEE_OperationHandle operation, 1249 const void *message, uint32_t messageLen, 1250 const void *mac, uint32_t macLen) 1251 { 1252 TEE_Result res; 1253 uint8_t computed_mac[TEE_MAX_HASH_SIZE] = { 0 }; 1254 uint32_t computed_mac_size = TEE_MAX_HASH_SIZE; 1255 1256 if (operation->info.operationClass != TEE_OPERATION_MAC) { 1257 res = TEE_ERROR_BAD_PARAMETERS; 1258 goto out; 1259 } 1260 1261 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 1262 res = TEE_ERROR_BAD_PARAMETERS; 1263 goto out; 1264 } 1265 1266 if (operation->operationState != TEE_OPERATION_STATE_ACTIVE) { 1267 res = TEE_ERROR_BAD_PARAMETERS; 1268 goto out; 1269 } 1270 1271 res = TEE_MACComputeFinal(operation, message, messageLen, computed_mac, 1272 &computed_mac_size); 1273 if (res != TEE_SUCCESS) 1274 goto out; 1275 1276 if (computed_mac_size != macLen) { 1277 res = TEE_ERROR_MAC_INVALID; 1278 goto out; 1279 } 1280 1281 if (consttime_memcmp(mac, computed_mac, computed_mac_size) != 0) { 1282 res = TEE_ERROR_MAC_INVALID; 1283 goto out; 1284 } 1285 1286 operation->operationState = TEE_OPERATION_STATE_INITIAL; 1287 1288 out: 1289 if (res != TEE_SUCCESS && 1290 res != TEE_ERROR_MAC_INVALID) 1291 TEE_Panic(res); 1292 1293 return res; 1294 } 1295 1296 /* Cryptographic Operations API - Authenticated Encryption Functions */ 1297 1298 TEE_Result TEE_AEInit(TEE_OperationHandle operation, const void *nonce, 1299 uint32_t nonceLen, uint32_t tagLen, uint32_t AADLen, 1300 uint32_t payloadLen) 1301 { 1302 TEE_Result res; 1303 1304 if (operation == TEE_HANDLE_NULL || nonce == NULL) { 1305 res = TEE_ERROR_BAD_PARAMETERS; 1306 goto out; 1307 } 1308 1309 if (operation->info.operationClass != TEE_OPERATION_AE) { 1310 res = TEE_ERROR_BAD_PARAMETERS; 1311 goto out; 1312 } 1313 1314 if (operation->operationState != TEE_OPERATION_STATE_INITIAL) { 1315 res = TEE_ERROR_BAD_PARAMETERS; 1316 goto out; 1317 } 1318 1319 /* 1320 * AES-CCM tag len is specified by AES-CCM spec and handled in TEE Core 1321 * in the implementation. But AES-GCM spec doesn't specify the tag len 1322 * according to the same principle so we have to check here instead to 1323 * be GP compliant. 1324 */ 1325 if (operation->info.algorithm == TEE_ALG_AES_GCM) { 1326 /* 1327 * From GP spec: For AES-GCM, can be 128, 120, 112, 104, or 96 1328 */ 1329 if (tagLen < 96 || tagLen > 128 || (tagLen % 8 != 0)) { 1330 res = TEE_ERROR_NOT_SUPPORTED; 1331 goto out; 1332 } 1333 } 1334 1335 res = _utee_authenc_init(operation->state, nonce, nonceLen, tagLen / 8, 1336 AADLen, payloadLen); 1337 if (res != TEE_SUCCESS) 1338 goto out; 1339 1340 operation->info.digestLength = tagLen / 8; 1341 operation->buffer_offs = 0; 1342 operation->info.handleState |= TEE_HANDLE_FLAG_INITIALIZED; 1343 1344 out: 1345 if (res != TEE_SUCCESS && 1346 res != TEE_ERROR_NOT_SUPPORTED) 1347 TEE_Panic(res); 1348 1349 return res; 1350 } 1351 1352 void TEE_AEUpdateAAD(TEE_OperationHandle operation, const void *AADdata, 1353 uint32_t AADdataLen) 1354 { 1355 TEE_Result res; 1356 1357 if (operation == TEE_HANDLE_NULL || 1358 (AADdata == NULL && AADdataLen != 0)) 1359 TEE_Panic(0); 1360 1361 if (operation->info.operationClass != TEE_OPERATION_AE) 1362 TEE_Panic(0); 1363 1364 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) 1365 TEE_Panic(0); 1366 1367 res = _utee_authenc_update_aad(operation->state, AADdata, AADdataLen); 1368 1369 operation->operationState = TEE_OPERATION_STATE_ACTIVE; 1370 1371 if (res != TEE_SUCCESS) 1372 TEE_Panic(res); 1373 } 1374 1375 TEE_Result TEE_AEUpdate(TEE_OperationHandle operation, const void *srcData, 1376 uint32_t srcLen, void *destData, uint32_t *destLen) 1377 { 1378 TEE_Result res = TEE_SUCCESS; 1379 size_t req_dlen = 0; 1380 uint64_t dl = 0; 1381 1382 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) { 1383 res = TEE_ERROR_BAD_PARAMETERS; 1384 goto out; 1385 } 1386 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 1387 1388 if (operation->info.operationClass != TEE_OPERATION_AE) { 1389 res = TEE_ERROR_BAD_PARAMETERS; 1390 goto out; 1391 } 1392 1393 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 1394 res = TEE_ERROR_BAD_PARAMETERS; 1395 goto out; 1396 } 1397 1398 if (!srcData && !srcLen) { 1399 *destLen = 0; 1400 res = TEE_SUCCESS; 1401 goto out; 1402 } 1403 1404 /* 1405 * Check that required destLen is big enough before starting to feed 1406 * data to the algorithm. Errors during feeding of data are fatal as we 1407 * can't restore sync with this API. 1408 */ 1409 if (operation->block_size > 1) { 1410 req_dlen = ROUNDDOWN(operation->buffer_offs + srcLen, 1411 operation->block_size); 1412 } else { 1413 req_dlen = srcLen; 1414 } 1415 1416 dl = *destLen; 1417 if (dl < req_dlen) { 1418 *destLen = req_dlen; 1419 res = TEE_ERROR_SHORT_BUFFER; 1420 goto out; 1421 } 1422 1423 if (operation->block_size > 1) { 1424 res = tee_buffer_update(operation, _utee_authenc_update_payload, 1425 srcData, srcLen, destData, &dl); 1426 } else { 1427 if (srcLen > 0) { 1428 res = _utee_authenc_update_payload(operation->state, 1429 srcData, srcLen, 1430 destData, &dl); 1431 } else { 1432 dl = 0; 1433 res = TEE_SUCCESS; 1434 } 1435 } 1436 if (res != TEE_SUCCESS) 1437 goto out; 1438 1439 *destLen = dl; 1440 1441 operation->operationState = TEE_OPERATION_STATE_ACTIVE; 1442 1443 out: 1444 if (res != TEE_SUCCESS && 1445 res != TEE_ERROR_SHORT_BUFFER) 1446 TEE_Panic(res); 1447 1448 return res; 1449 } 1450 1451 TEE_Result TEE_AEEncryptFinal(TEE_OperationHandle operation, 1452 const void *srcData, uint32_t srcLen, 1453 void *destData, uint32_t *destLen, void *tag, 1454 uint32_t *tagLen) 1455 { 1456 TEE_Result res; 1457 uint8_t *dst = destData; 1458 size_t acc_dlen = 0; 1459 uint64_t tmp_dlen; 1460 size_t req_dlen; 1461 uint64_t tl; 1462 1463 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) { 1464 res = TEE_ERROR_BAD_PARAMETERS; 1465 goto out; 1466 } 1467 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 1468 __utee_check_inout_annotation(tagLen, sizeof(*tagLen)); 1469 1470 if (operation->info.operationClass != TEE_OPERATION_AE) { 1471 res = TEE_ERROR_BAD_PARAMETERS; 1472 goto out; 1473 } 1474 1475 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 1476 res = TEE_ERROR_BAD_PARAMETERS; 1477 goto out; 1478 } 1479 1480 /* 1481 * Check that required destLen is big enough before starting to feed 1482 * data to the algorithm. Errors during feeding of data are fatal as we 1483 * can't restore sync with this API. 1484 * 1485 * Need to check this before update_payload since sync would be lost if 1486 * we return short buffer after that. 1487 */ 1488 res = TEE_ERROR_GENERIC; 1489 1490 req_dlen = operation->buffer_offs + srcLen; 1491 if (*destLen < req_dlen) { 1492 *destLen = req_dlen; 1493 res = TEE_ERROR_SHORT_BUFFER; 1494 } 1495 1496 if (*tagLen < operation->info.digestLength) { 1497 *tagLen = operation->info.digestLength; 1498 res = TEE_ERROR_SHORT_BUFFER; 1499 } 1500 1501 if (res == TEE_ERROR_SHORT_BUFFER) 1502 goto out; 1503 1504 tl = *tagLen; 1505 tmp_dlen = *destLen - acc_dlen; 1506 if (operation->block_size > 1) { 1507 res = tee_buffer_update(operation, _utee_authenc_update_payload, 1508 srcData, srcLen, dst, &tmp_dlen); 1509 if (res != TEE_SUCCESS) 1510 goto out; 1511 1512 dst += tmp_dlen; 1513 acc_dlen += tmp_dlen; 1514 1515 tmp_dlen = *destLen - acc_dlen; 1516 res = _utee_authenc_enc_final(operation->state, 1517 operation->buffer, 1518 operation->buffer_offs, dst, 1519 &tmp_dlen, tag, &tl); 1520 } else { 1521 res = _utee_authenc_enc_final(operation->state, srcData, 1522 srcLen, dst, &tmp_dlen, 1523 tag, &tl); 1524 } 1525 *tagLen = tl; 1526 if (res != TEE_SUCCESS) 1527 goto out; 1528 1529 acc_dlen += tmp_dlen; 1530 *destLen = acc_dlen; 1531 1532 operation->info.handleState &= ~TEE_HANDLE_FLAG_INITIALIZED; 1533 1534 operation->operationState = TEE_OPERATION_STATE_INITIAL; 1535 1536 out: 1537 if (res != TEE_SUCCESS && 1538 res != TEE_ERROR_SHORT_BUFFER) 1539 TEE_Panic(res); 1540 1541 return res; 1542 } 1543 1544 TEE_Result TEE_AEDecryptFinal(TEE_OperationHandle operation, 1545 const void *srcData, uint32_t srcLen, 1546 void *destData, uint32_t *destLen, void *tag, 1547 uint32_t tagLen) 1548 { 1549 TEE_Result res; 1550 uint8_t *dst = destData; 1551 size_t acc_dlen = 0; 1552 uint64_t tmp_dlen; 1553 size_t req_dlen; 1554 1555 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) { 1556 res = TEE_ERROR_BAD_PARAMETERS; 1557 goto out; 1558 } 1559 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 1560 1561 if (operation->info.operationClass != TEE_OPERATION_AE) { 1562 res = TEE_ERROR_BAD_PARAMETERS; 1563 goto out; 1564 } 1565 1566 if ((operation->info.handleState & TEE_HANDLE_FLAG_INITIALIZED) == 0) { 1567 res = TEE_ERROR_BAD_PARAMETERS; 1568 goto out; 1569 } 1570 1571 /* 1572 * Check that required destLen is big enough before starting to feed 1573 * data to the algorithm. Errors during feeding of data are fatal as we 1574 * can't restore sync with this API. 1575 */ 1576 req_dlen = operation->buffer_offs + srcLen; 1577 if (*destLen < req_dlen) { 1578 *destLen = req_dlen; 1579 res = TEE_ERROR_SHORT_BUFFER; 1580 goto out; 1581 } 1582 1583 tmp_dlen = *destLen - acc_dlen; 1584 if (operation->block_size > 1) { 1585 res = tee_buffer_update(operation, _utee_authenc_update_payload, 1586 srcData, srcLen, dst, &tmp_dlen); 1587 if (res != TEE_SUCCESS) 1588 goto out; 1589 1590 dst += tmp_dlen; 1591 acc_dlen += tmp_dlen; 1592 1593 tmp_dlen = *destLen - acc_dlen; 1594 res = _utee_authenc_dec_final(operation->state, 1595 operation->buffer, 1596 operation->buffer_offs, dst, 1597 &tmp_dlen, tag, tagLen); 1598 } else { 1599 res = _utee_authenc_dec_final(operation->state, srcData, 1600 srcLen, dst, &tmp_dlen, 1601 tag, tagLen); 1602 } 1603 if (res != TEE_SUCCESS) 1604 goto out; 1605 1606 /* Supplied tagLen should match what we initiated with */ 1607 if (tagLen != operation->info.digestLength) 1608 res = TEE_ERROR_MAC_INVALID; 1609 1610 acc_dlen += tmp_dlen; 1611 *destLen = acc_dlen; 1612 1613 operation->info.handleState &= ~TEE_HANDLE_FLAG_INITIALIZED; 1614 1615 operation->operationState = TEE_OPERATION_STATE_INITIAL; 1616 1617 out: 1618 if (res != TEE_SUCCESS && 1619 res != TEE_ERROR_SHORT_BUFFER && 1620 res != TEE_ERROR_MAC_INVALID) 1621 TEE_Panic(res); 1622 1623 return res; 1624 } 1625 1626 /* Cryptographic Operations API - Asymmetric Functions */ 1627 1628 TEE_Result TEE_AsymmetricEncrypt(TEE_OperationHandle operation, 1629 const TEE_Attribute *params, 1630 uint32_t paramCount, const void *srcData, 1631 uint32_t srcLen, void *destData, 1632 uint32_t *destLen) 1633 { 1634 TEE_Result res = TEE_SUCCESS; 1635 struct utee_attribute ua[paramCount]; 1636 uint64_t dl = 0; 1637 1638 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) 1639 TEE_Panic(0); 1640 1641 __utee_check_attr_in_annotation(params, paramCount); 1642 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 1643 1644 if (!operation->key1) 1645 TEE_Panic(0); 1646 if (operation->info.operationClass != TEE_OPERATION_ASYMMETRIC_CIPHER) 1647 TEE_Panic(0); 1648 if (operation->info.mode != TEE_MODE_ENCRYPT) 1649 TEE_Panic(0); 1650 1651 __utee_from_attr(ua, params, paramCount); 1652 dl = *destLen; 1653 res = _utee_asymm_operate(operation->state, ua, paramCount, srcData, 1654 srcLen, destData, &dl); 1655 *destLen = dl; 1656 1657 if (res != TEE_SUCCESS && 1658 res != TEE_ERROR_SHORT_BUFFER && 1659 res != TEE_ERROR_BAD_PARAMETERS) 1660 TEE_Panic(res); 1661 1662 return res; 1663 } 1664 1665 TEE_Result TEE_AsymmetricDecrypt(TEE_OperationHandle operation, 1666 const TEE_Attribute *params, 1667 uint32_t paramCount, const void *srcData, 1668 uint32_t srcLen, void *destData, 1669 uint32_t *destLen) 1670 { 1671 TEE_Result res = TEE_SUCCESS; 1672 struct utee_attribute ua[paramCount]; 1673 uint64_t dl = 0; 1674 1675 if (operation == TEE_HANDLE_NULL || (!srcData && srcLen)) 1676 TEE_Panic(0); 1677 1678 __utee_check_attr_in_annotation(params, paramCount); 1679 __utee_check_inout_annotation(destLen, sizeof(*destLen)); 1680 1681 if (!operation->key1) 1682 TEE_Panic(0); 1683 if (operation->info.operationClass != TEE_OPERATION_ASYMMETRIC_CIPHER) 1684 TEE_Panic(0); 1685 if (operation->info.mode != TEE_MODE_DECRYPT) 1686 TEE_Panic(0); 1687 1688 __utee_from_attr(ua, params, paramCount); 1689 dl = *destLen; 1690 res = _utee_asymm_operate(operation->state, ua, paramCount, srcData, 1691 srcLen, destData, &dl); 1692 *destLen = dl; 1693 1694 if (res != TEE_SUCCESS && 1695 res != TEE_ERROR_SHORT_BUFFER && 1696 res != TEE_ERROR_BAD_PARAMETERS) 1697 TEE_Panic(res); 1698 1699 return res; 1700 } 1701 1702 TEE_Result TEE_AsymmetricSignDigest(TEE_OperationHandle operation, 1703 const TEE_Attribute *params, 1704 uint32_t paramCount, const void *digest, 1705 uint32_t digestLen, void *signature, 1706 uint32_t *signatureLen) 1707 { 1708 TEE_Result res = TEE_SUCCESS; 1709 struct utee_attribute ua[paramCount]; 1710 uint64_t sl = 0; 1711 1712 if (operation == TEE_HANDLE_NULL || (!digest && digestLen)) 1713 TEE_Panic(0); 1714 1715 __utee_check_attr_in_annotation(params, paramCount); 1716 __utee_check_inout_annotation(signatureLen, sizeof(*signatureLen)); 1717 1718 if (!operation->key1) 1719 TEE_Panic(0); 1720 if (operation->info.operationClass != 1721 TEE_OPERATION_ASYMMETRIC_SIGNATURE) 1722 TEE_Panic(0); 1723 if (operation->info.mode != TEE_MODE_SIGN) 1724 TEE_Panic(0); 1725 1726 __utee_from_attr(ua, params, paramCount); 1727 sl = *signatureLen; 1728 res = _utee_asymm_operate(operation->state, ua, paramCount, digest, 1729 digestLen, signature, &sl); 1730 *signatureLen = sl; 1731 1732 if (res != TEE_SUCCESS && res != TEE_ERROR_SHORT_BUFFER) 1733 TEE_Panic(res); 1734 1735 return res; 1736 } 1737 1738 TEE_Result TEE_AsymmetricVerifyDigest(TEE_OperationHandle operation, 1739 const TEE_Attribute *params, 1740 uint32_t paramCount, const void *digest, 1741 uint32_t digestLen, 1742 const void *signature, 1743 uint32_t signatureLen) 1744 { 1745 TEE_Result res; 1746 struct utee_attribute ua[paramCount]; 1747 1748 if (operation == TEE_HANDLE_NULL || 1749 (digest == NULL && digestLen != 0) || 1750 (signature == NULL && signatureLen != 0)) 1751 TEE_Panic(0); 1752 1753 __utee_check_attr_in_annotation(params, paramCount); 1754 1755 if (!operation->key1) 1756 TEE_Panic(0); 1757 if (operation->info.operationClass != 1758 TEE_OPERATION_ASYMMETRIC_SIGNATURE) 1759 TEE_Panic(0); 1760 if (operation->info.mode != TEE_MODE_VERIFY) 1761 TEE_Panic(0); 1762 1763 __utee_from_attr(ua, params, paramCount); 1764 res = _utee_asymm_verify(operation->state, ua, paramCount, digest, 1765 digestLen, signature, signatureLen); 1766 1767 if (res != TEE_SUCCESS && res != TEE_ERROR_SIGNATURE_INVALID) 1768 TEE_Panic(res); 1769 1770 return res; 1771 } 1772 1773 /* Cryptographic Operations API - Key Derivation Functions */ 1774 1775 void TEE_DeriveKey(TEE_OperationHandle operation, 1776 const TEE_Attribute *params, uint32_t paramCount, 1777 TEE_ObjectHandle derivedKey) 1778 { 1779 TEE_Result res; 1780 TEE_ObjectInfo key_info; 1781 struct utee_attribute ua[paramCount]; 1782 1783 if (operation == TEE_HANDLE_NULL || derivedKey == 0) 1784 TEE_Panic(0); 1785 1786 __utee_check_attr_in_annotation(params, paramCount); 1787 1788 if (TEE_ALG_GET_CLASS(operation->info.algorithm) != 1789 TEE_OPERATION_KEY_DERIVATION) 1790 TEE_Panic(0); 1791 1792 if (operation->info.operationClass != TEE_OPERATION_KEY_DERIVATION) 1793 TEE_Panic(0); 1794 if (!operation->key1) 1795 TEE_Panic(0); 1796 if (operation->info.mode != TEE_MODE_DERIVE) 1797 TEE_Panic(0); 1798 if ((operation->info.handleState & TEE_HANDLE_FLAG_KEY_SET) == 0) 1799 TEE_Panic(0); 1800 1801 res = _utee_cryp_obj_get_info((unsigned long)derivedKey, &key_info); 1802 if (res != TEE_SUCCESS) 1803 TEE_Panic(res); 1804 1805 if (key_info.objectType != TEE_TYPE_GENERIC_SECRET) 1806 TEE_Panic(0); 1807 if ((key_info.handleFlags & TEE_HANDLE_FLAG_INITIALIZED) != 0) 1808 TEE_Panic(0); 1809 1810 __utee_from_attr(ua, params, paramCount); 1811 res = _utee_cryp_derive_key(operation->state, ua, paramCount, 1812 (unsigned long)derivedKey); 1813 if (res != TEE_SUCCESS) 1814 TEE_Panic(res); 1815 } 1816 1817 /* Cryptographic Operations API - Random Number Generation Functions */ 1818 1819 void TEE_GenerateRandom(void *randomBuffer, uint32_t randomBufferLen) 1820 { 1821 TEE_Result res; 1822 1823 res = _utee_cryp_random_number_generate(randomBuffer, randomBufferLen); 1824 if (res != TEE_SUCCESS) 1825 TEE_Panic(res); 1826 } 1827 1828 int rand(void) 1829 { 1830 int rc; 1831 1832 TEE_GenerateRandom(&rc, sizeof(rc)); 1833 1834 /* 1835 * RAND_MAX is the larges int, INT_MAX which is all bits but the 1836 * highest bit set. 1837 */ 1838 return rc & RAND_MAX; 1839 } 1840 1841 TEE_Result TEE_IsAlgorithmSupported(uint32_t alg, uint32_t element) 1842 { 1843 if (IS_ENABLED(CFG_CRYPTO_AES)) { 1844 if (IS_ENABLED(CFG_CRYPTO_ECB)) { 1845 if (alg == TEE_ALG_AES_ECB_NOPAD) 1846 goto check_element_none; 1847 } 1848 if (IS_ENABLED(CFG_CRYPTO_CBC)) { 1849 if (alg == TEE_ALG_AES_CBC_NOPAD) 1850 goto check_element_none; 1851 } 1852 if (IS_ENABLED(CFG_CRYPTO_CTR)) { 1853 if (alg == TEE_ALG_AES_CTR) 1854 goto check_element_none; 1855 } 1856 if (IS_ENABLED(CFG_CRYPTO_CTS)) { 1857 if (alg == TEE_ALG_AES_CTS) 1858 goto check_element_none; 1859 } 1860 if (IS_ENABLED(CFG_CRYPTO_XTS)) { 1861 if (alg == TEE_ALG_AES_XTS) 1862 goto check_element_none; 1863 } 1864 if (IS_ENABLED(CFG_CRYPTO_CBC_MAC)) { 1865 if (alg == TEE_ALG_AES_CBC_MAC_NOPAD || 1866 alg == TEE_ALG_AES_CBC_MAC_PKCS5) 1867 goto check_element_none; 1868 } 1869 if (IS_ENABLED(CFG_CRYPTO_CMAC)) { 1870 if (alg == TEE_ALG_AES_CMAC) 1871 goto check_element_none; 1872 } 1873 if (IS_ENABLED(CFG_CRYPTO_CCM)) { 1874 if (alg == TEE_ALG_AES_CCM) 1875 goto check_element_none; 1876 } 1877 if (IS_ENABLED(CFG_CRYPTO_GCM)) { 1878 if (alg == TEE_ALG_AES_GCM) 1879 goto check_element_none; 1880 } 1881 } 1882 if (IS_ENABLED(CFG_CRYPTO_DES)) { 1883 if (IS_ENABLED(CFG_CRYPTO_ECB)) { 1884 if (alg == TEE_ALG_DES_ECB_NOPAD || 1885 alg == TEE_ALG_DES3_ECB_NOPAD) 1886 goto check_element_none; 1887 } 1888 if (IS_ENABLED(CFG_CRYPTO_CBC)) { 1889 if (alg == TEE_ALG_DES_CBC_NOPAD || 1890 alg == TEE_ALG_DES3_CBC_NOPAD) 1891 goto check_element_none; 1892 } 1893 if (IS_ENABLED(CFG_CRYPTO_CBC_MAC)) { 1894 if (alg == TEE_ALG_DES_CBC_MAC_NOPAD || 1895 alg == TEE_ALG_DES_CBC_MAC_PKCS5 || 1896 alg == TEE_ALG_DES3_CBC_MAC_NOPAD || 1897 alg == TEE_ALG_DES3_CBC_MAC_PKCS5) 1898 goto check_element_none; 1899 } 1900 } 1901 if (IS_ENABLED(CFG_CRYPTO_MD5)) { 1902 if (alg == TEE_ALG_MD5) 1903 goto check_element_none; 1904 } 1905 if (IS_ENABLED(CFG_CRYPTO_SHA1)) { 1906 if (alg == TEE_ALG_SHA1) 1907 goto check_element_none; 1908 } 1909 if (IS_ENABLED(CFG_CRYPTO_SHA224)) { 1910 if (alg == TEE_ALG_SHA224) 1911 goto check_element_none; 1912 } 1913 if (IS_ENABLED(CFG_CRYPTO_SHA256)) { 1914 if (alg == TEE_ALG_SHA256) 1915 goto check_element_none; 1916 } 1917 if (IS_ENABLED(CFG_CRYPTO_SHA384)) { 1918 if (alg == TEE_ALG_SHA384) 1919 goto check_element_none; 1920 } 1921 if (IS_ENABLED(CFG_CRYPTO_SHA512)) { 1922 if (alg == TEE_ALG_SHA512) 1923 goto check_element_none; 1924 } 1925 if (IS_ENABLED(CFG_CRYPTO_MD5) && IS_ENABLED(CFG_CRYPTO_SHA1)) { 1926 if (alg == TEE_ALG_MD5SHA1) 1927 goto check_element_none; 1928 } 1929 if (IS_ENABLED(CFG_CRYPTO_HMAC)) { 1930 if (IS_ENABLED(CFG_CRYPTO_MD5)) { 1931 if (alg == TEE_ALG_HMAC_MD5) 1932 goto check_element_none; 1933 } 1934 if (IS_ENABLED(CFG_CRYPTO_SHA1)) { 1935 if (alg == TEE_ALG_HMAC_SHA1) 1936 goto check_element_none; 1937 } 1938 if (IS_ENABLED(CFG_CRYPTO_SHA224)) { 1939 if (alg == TEE_ALG_HMAC_SHA224) 1940 goto check_element_none; 1941 } 1942 if (IS_ENABLED(CFG_CRYPTO_SHA256)) { 1943 if (alg == TEE_ALG_HMAC_SHA256) 1944 goto check_element_none; 1945 } 1946 if (IS_ENABLED(CFG_CRYPTO_SHA384)) { 1947 if (alg == TEE_ALG_HMAC_SHA384) 1948 goto check_element_none; 1949 } 1950 if (IS_ENABLED(CFG_CRYPTO_SHA512)) { 1951 if (alg == TEE_ALG_HMAC_SHA512) 1952 goto check_element_none; 1953 } 1954 if (IS_ENABLED(CFG_CRYPTO_SM3)) { 1955 if (alg == TEE_ALG_HMAC_SM3) 1956 goto check_element_none; 1957 } 1958 } 1959 if (IS_ENABLED(CFG_CRYPTO_SM3)) { 1960 if (alg == TEE_ALG_SM3) 1961 goto check_element_none; 1962 } 1963 if (IS_ENABLED(CFG_CRYPTO_SM4)) { 1964 if (IS_ENABLED(CFG_CRYPTO_ECB)) { 1965 if (alg == TEE_ALG_SM4_ECB_NOPAD) 1966 goto check_element_none; 1967 } 1968 if (IS_ENABLED(CFG_CRYPTO_CBC)) { 1969 if (alg == TEE_ALG_SM4_CBC_NOPAD) 1970 goto check_element_none; 1971 } 1972 if (IS_ENABLED(CFG_CRYPTO_CTR)) { 1973 if (alg == TEE_ALG_SM4_CTR) 1974 goto check_element_none; 1975 } 1976 } 1977 if (IS_ENABLED(CFG_CRYPTO_RSA)) { 1978 if (IS_ENABLED(CFG_CRYPTO_MD5)) { 1979 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_MD5) 1980 goto check_element_none; 1981 } 1982 if (IS_ENABLED(CFG_CRYPTO_SHA1)) { 1983 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_SHA1 || 1984 alg == TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA1 || 1985 alg == TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA1) 1986 goto check_element_none; 1987 } 1988 if (IS_ENABLED(CFG_CRYPTO_MD5) && IS_ENABLED(CFG_CRYPTO_SHA1)) { 1989 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_MD5SHA1) 1990 goto check_element_none; 1991 } 1992 if (IS_ENABLED(CFG_CRYPTO_SHA224)) { 1993 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_SHA224 || 1994 alg == TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA224 || 1995 alg == TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA224) 1996 goto check_element_none; 1997 } 1998 if (IS_ENABLED(CFG_CRYPTO_SHA256)) { 1999 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_SHA256 || 2000 alg == TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA256 || 2001 alg == TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA256) 2002 goto check_element_none; 2003 } 2004 if (IS_ENABLED(CFG_CRYPTO_SHA384)) { 2005 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_SHA384 || 2006 alg == TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA384 || 2007 alg == TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA384) 2008 goto check_element_none; 2009 } 2010 if (IS_ENABLED(CFG_CRYPTO_SHA512)) { 2011 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5_SHA512 || 2012 alg == TEE_ALG_RSASSA_PKCS1_PSS_MGF1_SHA512 || 2013 alg == TEE_ALG_RSAES_PKCS1_OAEP_MGF1_SHA512) 2014 goto check_element_none; 2015 } 2016 if (IS_ENABLED(CFG_CRYPTO_RSASSA_NA1)) { 2017 if (alg == TEE_ALG_RSASSA_PKCS1_V1_5) 2018 goto check_element_none; 2019 } 2020 if (alg == TEE_ALG_RSA_NOPAD) 2021 goto check_element_none; 2022 } 2023 if (IS_ENABLED(CFG_CRYPTO_DSA)) { 2024 if (IS_ENABLED(CFG_CRYPTO_SHA1)) { 2025 if (alg == TEE_ALG_DSA_SHA1) 2026 goto check_element_none; 2027 } 2028 if (IS_ENABLED(CFG_CRYPTO_SHA224)) { 2029 if (alg == TEE_ALG_DSA_SHA224) 2030 goto check_element_none; 2031 } 2032 if (IS_ENABLED(CFG_CRYPTO_SHA256)) { 2033 if (alg == TEE_ALG_DSA_SHA256) 2034 goto check_element_none; 2035 } 2036 } 2037 if (IS_ENABLED(CFG_CRYPTO_DH)) { 2038 if (alg == TEE_ALG_DH_DERIVE_SHARED_SECRET) 2039 goto check_element_none; 2040 } 2041 if (IS_ENABLED(CFG_CRYPTO_ECC)) { 2042 if ((alg == TEE_ALG_ECDH_P192 || alg == TEE_ALG_ECDSA_P192) && 2043 element == TEE_ECC_CURVE_NIST_P192) 2044 return TEE_SUCCESS; 2045 if ((alg == TEE_ALG_ECDH_P224 || alg == TEE_ALG_ECDSA_P224) && 2046 element == TEE_ECC_CURVE_NIST_P224) 2047 return TEE_SUCCESS; 2048 if ((alg == TEE_ALG_ECDH_P256 || alg == TEE_ALG_ECDSA_P256) && 2049 element == TEE_ECC_CURVE_NIST_P256) 2050 return TEE_SUCCESS; 2051 if ((alg == TEE_ALG_ECDH_P384 || alg == TEE_ALG_ECDSA_P384) && 2052 element == TEE_ECC_CURVE_NIST_P384) 2053 return TEE_SUCCESS; 2054 if ((alg == TEE_ALG_ECDH_P521 || alg == TEE_ALG_ECDSA_P521) && 2055 element == TEE_ECC_CURVE_NIST_P521) 2056 return TEE_SUCCESS; 2057 } 2058 if (IS_ENABLED(CFG_CRYPTO_SM2_DSA)) { 2059 if (alg == TEE_ALG_SM2_DSA_SM3 && element == TEE_ECC_CURVE_SM2) 2060 return TEE_SUCCESS; 2061 } 2062 if (IS_ENABLED(CFG_CRYPTO_SM2_KEP)) { 2063 if (alg == TEE_ALG_SM2_KEP && element == TEE_ECC_CURVE_SM2) 2064 return TEE_SUCCESS; 2065 } 2066 if (IS_ENABLED(CFG_CRYPTO_SM2_PKE)) { 2067 if (alg == TEE_ALG_SM2_PKE && element == TEE_ECC_CURVE_SM2) 2068 return TEE_SUCCESS; 2069 } 2070 2071 return TEE_ERROR_NOT_SUPPORTED; 2072 check_element_none: 2073 if (element == TEE_CRYPTO_ELEMENT_NONE) 2074 return TEE_SUCCESS; 2075 return TEE_ERROR_NOT_SUPPORTED; 2076 } 2077