1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2017-2020, Linaro Limited 4 */ 5 6 #include <assert.h> 7 #include <pkcs11_ta.h> 8 #include <string.h> 9 #include <tee_api_defines.h> 10 #include <tee_internal_api.h> 11 #include <tee_internal_api_extensions.h> 12 #include <utee_defines.h> 13 #include <util.h> 14 15 #include "attributes.h" 16 #include "object.h" 17 #include "pkcs11_attributes.h" 18 #include "pkcs11_helpers.h" 19 #include "pkcs11_token.h" 20 #include "processing.h" 21 #include "serializer.h" 22 23 bool processing_is_tee_symm(enum pkcs11_mechanism_id proc_id) 24 { 25 switch (proc_id) { 26 /* Authentication */ 27 case PKCS11_CKM_MD5_HMAC: 28 case PKCS11_CKM_SHA_1_HMAC: 29 case PKCS11_CKM_SHA224_HMAC: 30 case PKCS11_CKM_SHA256_HMAC: 31 case PKCS11_CKM_SHA384_HMAC: 32 case PKCS11_CKM_SHA512_HMAC: 33 /* Cipherering */ 34 case PKCS11_CKM_AES_ECB: 35 case PKCS11_CKM_AES_CBC: 36 case PKCS11_CKM_AES_CBC_PAD: 37 case PKCS11_CKM_AES_CTS: 38 case PKCS11_CKM_AES_CTR: 39 return true; 40 default: 41 return false; 42 } 43 } 44 45 static enum pkcs11_rc 46 pkcs2tee_algorithm(uint32_t *tee_id, struct pkcs11_attribute_head *proc_params) 47 { 48 static const struct { 49 enum pkcs11_mechanism_id mech_id; 50 uint32_t tee_id; 51 } pkcs2tee_algo[] = { 52 /* AES flavors */ 53 { PKCS11_CKM_AES_ECB, TEE_ALG_AES_ECB_NOPAD }, 54 { PKCS11_CKM_AES_CBC, TEE_ALG_AES_CBC_NOPAD }, 55 { PKCS11_CKM_AES_CBC_PAD, TEE_ALG_AES_CBC_NOPAD }, 56 { PKCS11_CKM_AES_CTR, TEE_ALG_AES_CTR }, 57 { PKCS11_CKM_AES_CTS, TEE_ALG_AES_CTS }, 58 /* HMAC flavors */ 59 { PKCS11_CKM_MD5_HMAC, TEE_ALG_HMAC_MD5 }, 60 { PKCS11_CKM_SHA_1_HMAC, TEE_ALG_HMAC_SHA1 }, 61 { PKCS11_CKM_SHA224_HMAC, TEE_ALG_HMAC_SHA224 }, 62 { PKCS11_CKM_SHA256_HMAC, TEE_ALG_HMAC_SHA256 }, 63 { PKCS11_CKM_SHA384_HMAC, TEE_ALG_HMAC_SHA384 }, 64 { PKCS11_CKM_SHA512_HMAC, TEE_ALG_HMAC_SHA512 }, 65 }; 66 size_t n = 0; 67 68 for (n = 0; n < ARRAY_SIZE(pkcs2tee_algo); n++) { 69 if (proc_params->id == pkcs2tee_algo[n].mech_id) { 70 *tee_id = pkcs2tee_algo[n].tee_id; 71 return PKCS11_CKR_OK; 72 } 73 } 74 75 return PKCS11_RV_NOT_IMPLEMENTED; 76 } 77 78 static enum pkcs11_rc pkcs2tee_key_type(uint32_t *tee_type, 79 struct pkcs11_object *obj) 80 { 81 static const struct { 82 enum pkcs11_key_type key_type; 83 uint32_t tee_id; 84 } pkcs2tee_key_type[] = { 85 { PKCS11_CKK_AES, TEE_TYPE_AES }, 86 { PKCS11_CKK_GENERIC_SECRET, TEE_TYPE_GENERIC_SECRET }, 87 { PKCS11_CKK_MD5_HMAC, TEE_TYPE_HMAC_MD5 }, 88 { PKCS11_CKK_SHA_1_HMAC, TEE_TYPE_HMAC_SHA1 }, 89 { PKCS11_CKK_SHA224_HMAC, TEE_TYPE_HMAC_SHA224 }, 90 { PKCS11_CKK_SHA256_HMAC, TEE_TYPE_HMAC_SHA256 }, 91 { PKCS11_CKK_SHA384_HMAC, TEE_TYPE_HMAC_SHA384 }, 92 { PKCS11_CKK_SHA512_HMAC, TEE_TYPE_HMAC_SHA512 }, 93 }; 94 size_t n = 0; 95 enum pkcs11_key_type key_type = get_key_type(obj->attributes); 96 97 assert(get_class(obj->attributes) == PKCS11_CKO_SECRET_KEY); 98 99 for (n = 0; n < ARRAY_SIZE(pkcs2tee_key_type); n++) { 100 if (pkcs2tee_key_type[n].key_type == key_type) { 101 *tee_type = pkcs2tee_key_type[n].tee_id; 102 return PKCS11_CKR_OK; 103 } 104 } 105 106 return PKCS11_RV_NOT_FOUND; 107 } 108 109 static enum pkcs11_rc pkcsmech2tee_key_type(uint32_t *tee_type, 110 enum pkcs11_mechanism_id mech_id) 111 { 112 static const struct { 113 enum pkcs11_mechanism_id mech; 114 uint32_t tee_id; 115 } pkcs2tee_key_type[] = { 116 { PKCS11_CKM_MD5_HMAC, TEE_TYPE_HMAC_MD5 }, 117 { PKCS11_CKM_SHA_1_HMAC, TEE_TYPE_HMAC_SHA1 }, 118 { PKCS11_CKM_SHA224_HMAC, TEE_TYPE_HMAC_SHA224 }, 119 { PKCS11_CKM_SHA256_HMAC, TEE_TYPE_HMAC_SHA256 }, 120 { PKCS11_CKM_SHA384_HMAC, TEE_TYPE_HMAC_SHA384 }, 121 { PKCS11_CKM_SHA512_HMAC, TEE_TYPE_HMAC_SHA512 }, 122 }; 123 size_t n = 0; 124 125 for (n = 0; n < ARRAY_SIZE(pkcs2tee_key_type); n++) { 126 if (pkcs2tee_key_type[n].mech == mech_id) { 127 *tee_type = pkcs2tee_key_type[n].tee_id; 128 return PKCS11_CKR_OK; 129 } 130 } 131 132 return PKCS11_RV_NOT_FOUND; 133 } 134 135 static enum pkcs11_rc hmac_to_tee_hash(uint32_t *algo, 136 enum pkcs11_mechanism_id mech_id) 137 { 138 static const struct { 139 enum pkcs11_mechanism_id mech; 140 uint32_t tee_id; 141 } hmac_hash[] = { 142 { PKCS11_CKM_MD5_HMAC, TEE_ALG_MD5 }, 143 { PKCS11_CKM_SHA_1_HMAC, TEE_ALG_SHA1 }, 144 { PKCS11_CKM_SHA224_HMAC, TEE_ALG_SHA224 }, 145 { PKCS11_CKM_SHA256_HMAC, TEE_ALG_SHA256 }, 146 { PKCS11_CKM_SHA384_HMAC, TEE_ALG_SHA384 }, 147 { PKCS11_CKM_SHA512_HMAC, TEE_ALG_SHA512 }, 148 }; 149 size_t n = 0; 150 151 for (n = 0; n < ARRAY_SIZE(hmac_hash); n++) { 152 if (hmac_hash[n].mech == mech_id) { 153 *algo = hmac_hash[n].tee_id; 154 return PKCS11_CKR_OK; 155 } 156 } 157 158 return PKCS11_RV_NOT_FOUND; 159 } 160 161 static enum pkcs11_rc 162 allocate_tee_operation(struct pkcs11_session *session, 163 enum processing_func function, 164 struct pkcs11_attribute_head *params, 165 struct pkcs11_object *obj) 166 { 167 uint32_t size = (uint32_t)get_object_key_bit_size(obj); 168 uint32_t key_size = size / 8; 169 uint32_t algo = 0; 170 uint32_t mode = 0; 171 uint32_t max_key_size = 0; 172 uint32_t min_key_size = 0; 173 TEE_Result res = TEE_ERROR_GENERIC; 174 175 assert(session->processing->tee_op_handle == TEE_HANDLE_NULL); 176 177 if (pkcs2tee_algorithm(&algo, params)) 178 return PKCS11_CKR_FUNCTION_FAILED; 179 180 /* Sign/Verify with AES or generic key relate to TEE MAC operation */ 181 switch (params->id) { 182 case PKCS11_CKM_MD5_HMAC: 183 case PKCS11_CKM_SHA_1_HMAC: 184 case PKCS11_CKM_SHA224_HMAC: 185 case PKCS11_CKM_SHA256_HMAC: 186 case PKCS11_CKM_SHA384_HMAC: 187 case PKCS11_CKM_SHA512_HMAC: 188 mechanism_supported_key_sizes(params->id, 189 &min_key_size, 190 &max_key_size); 191 if (key_size < min_key_size) 192 return PKCS11_CKR_KEY_SIZE_RANGE; 193 194 /* 195 * If size of generic key is greater than the size 196 * supported by TEE API, this is not considered an 197 * error. When loading TEE key, we will hash the key 198 * to generate the appropriate key for HMAC operation. 199 * This key size will not be greater than the 200 * max_key_size. So we can use max_key_size for 201 * TEE_AllocateOperation(). 202 */ 203 if (key_size > max_key_size) 204 size = max_key_size * 8; 205 206 mode = TEE_MODE_MAC; 207 break; 208 default: 209 pkcs2tee_mode(&mode, function); 210 break; 211 } 212 213 res = TEE_AllocateOperation(&session->processing->tee_op_handle, 214 algo, mode, size); 215 if (res) 216 EMSG("TEE_AllocateOp. failed %#"PRIx32" %#"PRIx32" %#"PRIx32, 217 algo, mode, size); 218 219 if (res == TEE_ERROR_NOT_SUPPORTED) 220 return PKCS11_CKR_MECHANISM_INVALID; 221 222 return tee2pkcs_error(res); 223 } 224 225 static enum pkcs11_rc hash_secret_helper(enum pkcs11_mechanism_id mech_id, 226 struct pkcs11_object *obj, 227 TEE_Attribute *tee_attr, 228 void **ctx, 229 size_t *object_size_bits) 230 { 231 uint32_t algo = 0; 232 void *hash_ptr = NULL; 233 uint32_t hash_size = 0; 234 enum pkcs11_rc rc = PKCS11_CKR_OK; 235 236 rc = hmac_to_tee_hash(&algo, mech_id); 237 if (rc) 238 return rc; 239 240 hash_size = TEE_ALG_GET_DIGEST_SIZE(algo); 241 hash_ptr = TEE_Malloc(hash_size, 0); 242 if (!hash_ptr) 243 return PKCS11_CKR_DEVICE_MEMORY; 244 245 rc = pkcs2tee_load_hashed_attr(tee_attr, TEE_ATTR_SECRET_VALUE, obj, 246 PKCS11_CKA_VALUE, algo, hash_ptr, 247 &hash_size); 248 if (rc) { 249 EMSG("No secret/hash error"); 250 TEE_Free(hash_ptr); 251 return rc; 252 } 253 254 *ctx = hash_ptr; 255 256 *object_size_bits = hash_size * 8; 257 258 return PKCS11_CKR_OK; 259 } 260 261 static enum pkcs11_rc load_tee_key(struct pkcs11_session *session, 262 struct pkcs11_object *obj, 263 struct pkcs11_attribute_head *proc_params) 264 { 265 TEE_Attribute tee_attr = { }; 266 size_t object_size = 0; 267 uint32_t tee_key_type = 0; 268 enum pkcs11_key_type key_type = 0; 269 enum pkcs11_rc rc = PKCS11_CKR_OK; 270 TEE_Result res = TEE_ERROR_GENERIC; 271 uint32_t max_key_size = 0; 272 uint32_t min_key_size = 0; 273 274 if (obj->key_handle != TEE_HANDLE_NULL) { 275 /* Key was already loaded and fits current need */ 276 goto key_ready; 277 } 278 279 object_size = get_object_key_bit_size(obj); 280 if (!object_size) 281 return PKCS11_CKR_GENERAL_ERROR; 282 283 switch (proc_params->id) { 284 case PKCS11_CKM_MD5_HMAC: 285 case PKCS11_CKM_SHA_1_HMAC: 286 case PKCS11_CKM_SHA224_HMAC: 287 case PKCS11_CKM_SHA256_HMAC: 288 case PKCS11_CKM_SHA384_HMAC: 289 case PKCS11_CKM_SHA512_HMAC: 290 key_type = get_key_type(obj->attributes); 291 /* 292 * If Object Key type is PKCS11_CKK_GENERIC_SECRET, 293 * determine the tee_key_type using the 294 * mechanism instead of object key_type. 295 */ 296 if (key_type == PKCS11_CKK_GENERIC_SECRET) 297 rc = pkcsmech2tee_key_type(&tee_key_type, 298 proc_params->id); 299 else 300 rc = pkcs2tee_key_type(&tee_key_type, obj); 301 302 if (rc) 303 return rc; 304 305 mechanism_supported_key_sizes(proc_params->id, 306 &min_key_size, 307 &max_key_size); 308 309 if ((object_size / 8) > max_key_size) { 310 rc = hash_secret_helper(proc_params->id, obj, &tee_attr, 311 &session->processing->extra_ctx, 312 &object_size); 313 if (rc) 314 return rc; 315 } else { 316 if (!pkcs2tee_load_attr(&tee_attr, 317 TEE_ATTR_SECRET_VALUE, 318 obj, 319 PKCS11_CKA_VALUE)) { 320 EMSG("No secret found"); 321 return PKCS11_CKR_FUNCTION_FAILED; 322 } 323 } 324 break; 325 326 default: 327 rc = pkcs2tee_key_type(&tee_key_type, obj); 328 if (rc) 329 return rc; 330 331 if (!pkcs2tee_load_attr(&tee_attr, TEE_ATTR_SECRET_VALUE, 332 obj, PKCS11_CKA_VALUE)) { 333 EMSG("No secret found"); 334 return PKCS11_CKR_FUNCTION_FAILED; 335 } 336 break; 337 } 338 339 res = TEE_AllocateTransientObject(tee_key_type, object_size, 340 &obj->key_handle); 341 if (res) { 342 DMSG("TEE_AllocateTransientObject failed, %#"PRIx32, res); 343 return tee2pkcs_error(res); 344 } 345 346 res = TEE_PopulateTransientObject(obj->key_handle, &tee_attr, 1); 347 if (res) { 348 DMSG("TEE_PopulateTransientObject failed, %#"PRIx32, res); 349 goto error; 350 } 351 352 key_ready: 353 res = TEE_SetOperationKey(session->processing->tee_op_handle, 354 obj->key_handle); 355 if (res) { 356 DMSG("TEE_SetOperationKey failed, %#"PRIx32, res); 357 goto error; 358 } 359 360 return PKCS11_CKR_OK; 361 362 error: 363 TEE_FreeTransientObject(obj->key_handle); 364 obj->key_handle = TEE_HANDLE_NULL; 365 366 return tee2pkcs_error(res); 367 } 368 369 static enum pkcs11_rc 370 init_tee_operation(struct pkcs11_session *session, 371 struct pkcs11_attribute_head *proc_params) 372 { 373 enum pkcs11_rc rc = PKCS11_CKR_GENERAL_ERROR; 374 375 switch (proc_params->id) { 376 case PKCS11_CKM_MD5_HMAC: 377 case PKCS11_CKM_SHA_1_HMAC: 378 case PKCS11_CKM_SHA224_HMAC: 379 case PKCS11_CKM_SHA256_HMAC: 380 case PKCS11_CKM_SHA384_HMAC: 381 case PKCS11_CKM_SHA512_HMAC: 382 if (proc_params->size) 383 return PKCS11_CKR_MECHANISM_PARAM_INVALID; 384 385 TEE_MACInit(session->processing->tee_op_handle, NULL, 0); 386 rc = PKCS11_CKR_OK; 387 break; 388 case PKCS11_CKM_AES_ECB: 389 if (proc_params->size) 390 return PKCS11_CKR_MECHANISM_PARAM_INVALID; 391 392 TEE_CipherInit(session->processing->tee_op_handle, NULL, 0); 393 rc = PKCS11_CKR_OK; 394 break; 395 case PKCS11_CKM_AES_CBC: 396 case PKCS11_CKM_AES_CBC_PAD: 397 case PKCS11_CKM_AES_CTS: 398 if (proc_params->size != 16) 399 return PKCS11_CKR_MECHANISM_PARAM_INVALID; 400 401 TEE_CipherInit(session->processing->tee_op_handle, 402 proc_params->data, 16); 403 rc = PKCS11_CKR_OK; 404 break; 405 case PKCS11_CKM_AES_CTR: 406 rc = tee_init_ctr_operation(session->processing, 407 proc_params->data, 408 proc_params->size); 409 break; 410 default: 411 TEE_Panic(proc_params->id); 412 break; 413 } 414 415 return rc; 416 } 417 418 enum pkcs11_rc init_symm_operation(struct pkcs11_session *session, 419 enum processing_func function, 420 struct pkcs11_attribute_head *proc_params, 421 struct pkcs11_object *obj) 422 { 423 enum pkcs11_rc rc = PKCS11_CKR_OK; 424 425 assert(processing_is_tee_symm(proc_params->id)); 426 427 rc = allocate_tee_operation(session, function, proc_params, obj); 428 if (rc) 429 return rc; 430 431 rc = load_tee_key(session, obj, proc_params); 432 if (rc) 433 return rc; 434 435 return init_tee_operation(session, proc_params); 436 } 437 438 /* Validate input buffer size as per PKCS#11 constraints */ 439 static enum pkcs11_rc input_data_size_is_valid(struct active_processing *proc, 440 enum processing_func function, 441 size_t in_size) 442 { 443 switch (proc->mecha_type) { 444 case PKCS11_CKM_AES_ECB: 445 case PKCS11_CKM_AES_CBC: 446 if (function == PKCS11_FUNCTION_ENCRYPT && 447 in_size % TEE_AES_BLOCK_SIZE) 448 return PKCS11_CKR_DATA_LEN_RANGE; 449 if (function == PKCS11_FUNCTION_DECRYPT && 450 in_size % TEE_AES_BLOCK_SIZE) 451 return PKCS11_CKR_ENCRYPTED_DATA_LEN_RANGE; 452 break; 453 case PKCS11_CKM_AES_CBC_PAD: 454 if (function == PKCS11_FUNCTION_DECRYPT && 455 in_size % TEE_AES_BLOCK_SIZE) 456 return PKCS11_CKR_ENCRYPTED_DATA_LEN_RANGE; 457 break; 458 case PKCS11_CKM_AES_CTS: 459 if (function == PKCS11_FUNCTION_ENCRYPT && 460 in_size < TEE_AES_BLOCK_SIZE) 461 return PKCS11_CKR_DATA_LEN_RANGE; 462 if (function == PKCS11_FUNCTION_DECRYPT && 463 in_size < TEE_AES_BLOCK_SIZE) 464 return PKCS11_CKR_ENCRYPTED_DATA_LEN_RANGE; 465 break; 466 default: 467 break; 468 } 469 470 return PKCS11_CKR_OK; 471 } 472 473 /* Validate input buffer size as per PKCS#11 constraints */ 474 static enum pkcs11_rc input_sign_size_is_valid(struct active_processing *proc, 475 size_t in_size) 476 { 477 size_t sign_sz = 0; 478 479 switch (proc->mecha_type) { 480 case PKCS11_CKM_MD5_HMAC: 481 sign_sz = TEE_MD5_HASH_SIZE; 482 break; 483 case PKCS11_CKM_SHA_1_HMAC: 484 sign_sz = TEE_SHA1_HASH_SIZE; 485 break; 486 case PKCS11_CKM_SHA224_HMAC: 487 sign_sz = TEE_SHA224_HASH_SIZE; 488 break; 489 case PKCS11_CKM_SHA256_HMAC: 490 sign_sz = TEE_SHA256_HASH_SIZE; 491 break; 492 case PKCS11_CKM_SHA384_HMAC: 493 sign_sz = TEE_SHA384_HASH_SIZE; 494 break; 495 case PKCS11_CKM_SHA512_HMAC: 496 sign_sz = TEE_SHA512_HASH_SIZE; 497 break; 498 default: 499 return PKCS11_CKR_GENERAL_ERROR; 500 } 501 502 if (in_size < sign_sz) 503 return PKCS11_CKR_SIGNATURE_LEN_RANGE; 504 505 return PKCS11_CKR_OK; 506 } 507 508 /* 509 * step_sym_cipher - processing symmetric (and related) cipher operation step 510 * 511 * @session - current session 512 * @function - processing function (encrypt, decrypt, sign, ...) 513 * @step - step ID in the processing (oneshot, update, final) 514 * @ptype - invocation parameter types 515 * @params - invocation parameter references 516 */ 517 enum pkcs11_rc step_symm_operation(struct pkcs11_session *session, 518 enum processing_func function, 519 enum processing_step step, 520 uint32_t ptypes, TEE_Param *params) 521 { 522 enum pkcs11_rc rc = PKCS11_CKR_GENERAL_ERROR; 523 TEE_Result res = TEE_ERROR_GENERIC; 524 void *in_buf = NULL; 525 size_t in_size = 0; 526 void *out_buf = NULL; 527 uint32_t out_size = 0; 528 void *in2_buf = NULL; 529 uint32_t in2_size = 0; 530 bool output_data = false; 531 struct active_processing *proc = session->processing; 532 533 if (TEE_PARAM_TYPE_GET(ptypes, 1) == TEE_PARAM_TYPE_MEMREF_INPUT) { 534 in_buf = params[1].memref.buffer; 535 in_size = params[1].memref.size; 536 if (in_size && !in_buf) 537 return PKCS11_CKR_ARGUMENTS_BAD; 538 } 539 if (TEE_PARAM_TYPE_GET(ptypes, 2) == TEE_PARAM_TYPE_MEMREF_INPUT) { 540 in2_buf = params[2].memref.buffer; 541 in2_size = params[2].memref.size; 542 if (in2_size && !in2_buf) 543 return PKCS11_CKR_ARGUMENTS_BAD; 544 } 545 if (TEE_PARAM_TYPE_GET(ptypes, 2) == TEE_PARAM_TYPE_MEMREF_OUTPUT) { 546 out_buf = params[2].memref.buffer; 547 out_size = params[2].memref.size; 548 if (out_size && !out_buf) 549 return PKCS11_CKR_ARGUMENTS_BAD; 550 } 551 if (TEE_PARAM_TYPE_GET(ptypes, 3) != TEE_PARAM_TYPE_NONE) 552 return PKCS11_CKR_ARGUMENTS_BAD; 553 554 switch (step) { 555 case PKCS11_FUNC_STEP_ONESHOT: 556 case PKCS11_FUNC_STEP_UPDATE: 557 case PKCS11_FUNC_STEP_FINAL: 558 break; 559 default: 560 return PKCS11_CKR_GENERAL_ERROR; 561 } 562 563 if (step != PKCS11_FUNC_STEP_FINAL) { 564 rc = input_data_size_is_valid(proc, function, in_size); 565 if (rc) 566 return rc; 567 } 568 569 /* 570 * Feed active operation with data 571 */ 572 switch (proc->mecha_type) { 573 case PKCS11_CKM_MD5_HMAC: 574 case PKCS11_CKM_SHA_1_HMAC: 575 case PKCS11_CKM_SHA224_HMAC: 576 case PKCS11_CKM_SHA256_HMAC: 577 case PKCS11_CKM_SHA384_HMAC: 578 case PKCS11_CKM_SHA512_HMAC: 579 if (step == PKCS11_FUNC_STEP_FINAL || 580 step == PKCS11_FUNC_STEP_ONESHOT) 581 break; 582 583 if (!in_buf) { 584 DMSG("No input data"); 585 return PKCS11_CKR_ARGUMENTS_BAD; 586 } 587 588 switch (function) { 589 case PKCS11_FUNCTION_SIGN: 590 case PKCS11_FUNCTION_VERIFY: 591 TEE_MACUpdate(proc->tee_op_handle, in_buf, in_size); 592 rc = PKCS11_CKR_OK; 593 break; 594 default: 595 TEE_Panic(function); 596 break; 597 } 598 break; 599 600 case PKCS11_CKM_AES_ECB: 601 case PKCS11_CKM_AES_CBC: 602 case PKCS11_CKM_AES_CBC_PAD: 603 case PKCS11_CKM_AES_CTS: 604 case PKCS11_CKM_AES_CTR: 605 if (step == PKCS11_FUNC_STEP_FINAL || 606 step == PKCS11_FUNC_STEP_ONESHOT) 607 break; 608 609 if (!in_buf) { 610 EMSG("No input data"); 611 return PKCS11_CKR_ARGUMENTS_BAD; 612 } 613 614 switch (function) { 615 case PKCS11_FUNCTION_ENCRYPT: 616 case PKCS11_FUNCTION_DECRYPT: 617 res = TEE_CipherUpdate(proc->tee_op_handle, 618 in_buf, in_size, 619 out_buf, &out_size); 620 output_data = true; 621 rc = tee2pkcs_error(res); 622 break; 623 default: 624 TEE_Panic(function); 625 break; 626 } 627 break; 628 629 default: 630 TEE_Panic(proc->mecha_type); 631 break; 632 } 633 634 if (step == PKCS11_FUNC_STEP_UPDATE) 635 goto out; 636 637 /* 638 * Finalize (PKCS11_FUNC_STEP_ONESHOT/_FINAL) operation 639 */ 640 switch (session->processing->mecha_type) { 641 case PKCS11_CKM_MD5_HMAC: 642 case PKCS11_CKM_SHA_1_HMAC: 643 case PKCS11_CKM_SHA224_HMAC: 644 case PKCS11_CKM_SHA256_HMAC: 645 case PKCS11_CKM_SHA384_HMAC: 646 case PKCS11_CKM_SHA512_HMAC: 647 switch (function) { 648 case PKCS11_FUNCTION_SIGN: 649 res = TEE_MACComputeFinal(proc->tee_op_handle, 650 in_buf, in_size, out_buf, 651 &out_size); 652 output_data = true; 653 rc = tee2pkcs_error(res); 654 break; 655 case PKCS11_FUNCTION_VERIFY: 656 rc = input_sign_size_is_valid(proc, in2_size); 657 if (rc) 658 return rc; 659 res = TEE_MACCompareFinal(proc->tee_op_handle, 660 in_buf, in_size, in2_buf, 661 in2_size); 662 rc = tee2pkcs_error(res); 663 break; 664 default: 665 TEE_Panic(function); 666 break; 667 } 668 669 break; 670 671 case PKCS11_CKM_AES_ECB: 672 case PKCS11_CKM_AES_CBC: 673 case PKCS11_CKM_AES_CBC_PAD: 674 case PKCS11_CKM_AES_CTS: 675 case PKCS11_CKM_AES_CTR: 676 if (step == PKCS11_FUNC_STEP_ONESHOT && !in_buf) { 677 EMSG("No input data"); 678 return PKCS11_CKR_ARGUMENTS_BAD; 679 } 680 681 switch (function) { 682 case PKCS11_FUNCTION_ENCRYPT: 683 case PKCS11_FUNCTION_DECRYPT: 684 res = TEE_CipherDoFinal(proc->tee_op_handle, 685 in_buf, in_size, 686 out_buf, &out_size); 687 output_data = true; 688 rc = tee2pkcs_error(res); 689 break; 690 default: 691 TEE_Panic(function); 692 break; 693 } 694 break; 695 default: 696 TEE_Panic(proc->mecha_type); 697 break; 698 } 699 700 out: 701 if (output_data && 702 (rc == PKCS11_CKR_OK || rc == PKCS11_CKR_BUFFER_TOO_SMALL)) { 703 switch (TEE_PARAM_TYPE_GET(ptypes, 2)) { 704 case TEE_PARAM_TYPE_MEMREF_OUTPUT: 705 case TEE_PARAM_TYPE_MEMREF_INOUT: 706 params[2].memref.size = out_size; 707 break; 708 default: 709 rc = PKCS11_CKR_ARGUMENTS_BAD; 710 break; 711 } 712 } 713 714 return rc; 715 } 716