1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2017-2020, Linaro Limited 4 */ 5 6 #include <assert.h> 7 #include <inttypes.h> 8 #include <pkcs11_ta.h> 9 #include <stdlib.h> 10 #include <string_ext.h> 11 #include <tee_internal_api_extensions.h> 12 #include <tee_internal_api.h> 13 #include <trace.h> 14 #include <util.h> 15 16 #include "attributes.h" 17 #include "handle.h" 18 #include "pkcs11_attributes.h" 19 #include "pkcs11_helpers.h" 20 #include "pkcs11_token.h" 21 #include "sanitize_object.h" 22 #include "serializer.h" 23 #include "token_capabilities.h" 24 25 /* Byte size of CKA_ID attribute when generated locally */ 26 #define PKCS11_CKA_DEFAULT_SIZE 16 27 28 static uint32_t pkcs11_func2ckfm(enum processing_func function) 29 { 30 switch (function) { 31 case PKCS11_FUNCTION_DIGEST: 32 return PKCS11_CKFM_DIGEST; 33 case PKCS11_FUNCTION_GENERATE: 34 return PKCS11_CKFM_GENERATE; 35 case PKCS11_FUNCTION_GENERATE_PAIR: 36 return PKCS11_CKFM_GENERATE_KEY_PAIR; 37 case PKCS11_FUNCTION_DERIVE: 38 return PKCS11_CKFM_DERIVE; 39 case PKCS11_FUNCTION_WRAP: 40 return PKCS11_CKFM_WRAP; 41 case PKCS11_FUNCTION_UNWRAP: 42 return PKCS11_CKFM_UNWRAP; 43 case PKCS11_FUNCTION_ENCRYPT: 44 return PKCS11_CKFM_ENCRYPT; 45 case PKCS11_FUNCTION_DECRYPT: 46 return PKCS11_CKFM_DECRYPT; 47 case PKCS11_FUNCTION_SIGN: 48 return PKCS11_CKFM_SIGN; 49 case PKCS11_FUNCTION_VERIFY: 50 return PKCS11_CKFM_VERIFY; 51 case PKCS11_FUNCTION_SIGN_RECOVER: 52 return PKCS11_CKFM_SIGN_RECOVER; 53 case PKCS11_FUNCTION_VERIFY_RECOVER: 54 return PKCS11_CKFM_VERIFY_RECOVER; 55 default: 56 return 0; 57 } 58 } 59 60 enum pkcs11_rc 61 check_mechanism_against_processing(struct pkcs11_session *session, 62 enum pkcs11_mechanism_id mechanism_type, 63 enum processing_func function, 64 enum processing_step step) 65 { 66 bool allowed = false; 67 68 switch (step) { 69 case PKCS11_FUNC_STEP_INIT: 70 switch (function) { 71 case PKCS11_FUNCTION_IMPORT: 72 case PKCS11_FUNCTION_COPY: 73 case PKCS11_FUNCTION_MODIFY: 74 case PKCS11_FUNCTION_DESTROY: 75 return PKCS11_CKR_OK; 76 default: 77 break; 78 } 79 /* 80 * Check that the returned PKCS11_CKFM_* flag from 81 * pkcs11_func2ckfm() is among the ones from 82 * mechanism_supported_flags(). 83 */ 84 allowed = mechanism_supported_flags(mechanism_type) & 85 pkcs11_func2ckfm(function); 86 break; 87 88 case PKCS11_FUNC_STEP_ONESHOT: 89 case PKCS11_FUNC_STEP_UPDATE: 90 if (session->processing->always_authen && 91 !session->processing->relogged) 92 return PKCS11_CKR_USER_NOT_LOGGED_IN; 93 94 if (!session->processing->updated) 95 allowed = true; 96 else 97 allowed = !mechanism_is_one_shot_only(mechanism_type); 98 break; 99 100 case PKCS11_FUNC_STEP_FINAL: 101 if (session->processing->always_authen && 102 !session->processing->relogged) 103 return PKCS11_CKR_USER_NOT_LOGGED_IN; 104 105 return PKCS11_CKR_OK; 106 107 default: 108 TEE_Panic(step); 109 break; 110 } 111 112 if (!allowed) { 113 EMSG("Processing %#x/%s not permitted (%u/%u)", 114 (unsigned int)mechanism_type, id2str_proc(mechanism_type), 115 function, step); 116 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 117 } 118 119 return PKCS11_CKR_OK; 120 } 121 122 /* 123 * Object default boolean attributes as per PKCS#11 124 */ 125 static uint8_t *pkcs11_object_default_boolprop(uint32_t attribute) 126 { 127 static const uint8_t bool_true = 1; 128 static const uint8_t bool_false; 129 130 switch (attribute) { 131 /* As per PKCS#11 default value */ 132 case PKCS11_CKA_MODIFIABLE: 133 case PKCS11_CKA_COPYABLE: 134 case PKCS11_CKA_DESTROYABLE: 135 return (uint8_t *)&bool_true; 136 case PKCS11_CKA_TOKEN: 137 case PKCS11_CKA_PRIVATE: 138 case PKCS11_CKA_WRAP_WITH_TRUSTED: 139 case PKCS11_CKA_ALWAYS_AUTHENTICATE: 140 case PKCS11_CKA_SENSITIVE: 141 return (uint8_t *)&bool_false; 142 /* Token specific default value */ 143 case PKCS11_CKA_SIGN: 144 case PKCS11_CKA_VERIFY: 145 case PKCS11_CKA_DERIVE: 146 case PKCS11_CKA_ENCRYPT: 147 case PKCS11_CKA_DECRYPT: 148 case PKCS11_CKA_SIGN_RECOVER: 149 case PKCS11_CKA_VERIFY_RECOVER: 150 case PKCS11_CKA_WRAP: 151 case PKCS11_CKA_UNWRAP: 152 case PKCS11_CKA_EXTRACTABLE: 153 case PKCS11_CKA_TRUSTED: 154 return (uint8_t *)&bool_false; 155 default: 156 DMSG("No default for boolprop attribute %#"PRIx32, attribute); 157 return NULL; 158 } 159 } 160 161 /* 162 * Object expects several boolean attributes to be set to a default value 163 * or to a validate client configuration value. This function append the input 164 * attribute (id/size/value) in the serialized object. 165 */ 166 static enum pkcs11_rc pkcs11_import_object_boolprop(struct obj_attrs **out, 167 struct obj_attrs *templ, 168 uint32_t attribute) 169 { 170 enum pkcs11_rc rc = PKCS11_CKR_OK; 171 uint8_t bbool = 0; 172 uint32_t size = sizeof(uint8_t); 173 void *attr = NULL; 174 175 rc = get_attribute(templ, attribute, &bbool, &size); 176 if (rc) { 177 if (rc != PKCS11_RV_NOT_FOUND) 178 return rc; 179 attr = pkcs11_object_default_boolprop(attribute); 180 if (!attr) 181 return PKCS11_CKR_TEMPLATE_INCOMPLETE; 182 } else { 183 attr = &bbool; 184 } 185 186 /* Boolean attributes are 1byte in the ABI, no alignment issue */ 187 return add_attribute(out, attribute, attr, sizeof(uint8_t)); 188 } 189 190 static enum pkcs11_rc set_mandatory_boolprops(struct obj_attrs **out, 191 struct obj_attrs *temp, 192 uint32_t const *bp, 193 size_t bp_count) 194 { 195 enum pkcs11_rc rc = PKCS11_CKR_OK; 196 size_t n = 0; 197 198 for (n = 0; n < bp_count; n++) { 199 rc = pkcs11_import_object_boolprop(out, temp, bp[n]); 200 if (rc) 201 return rc; 202 } 203 204 return rc; 205 } 206 207 static enum pkcs11_rc set_mandatory_attributes(struct obj_attrs **out, 208 struct obj_attrs *temp, 209 uint32_t const *bp, 210 size_t bp_count) 211 { 212 enum pkcs11_rc rc = PKCS11_CKR_OK; 213 size_t n = 0; 214 215 for (n = 0; n < bp_count; n++) { 216 uint32_t size = 0; 217 void *value = NULL; 218 219 if (get_attribute_ptr(temp, bp[n], &value, &size)) 220 return PKCS11_CKR_TEMPLATE_INCOMPLETE; 221 222 rc = add_attribute(out, bp[n], value, size); 223 if (rc) 224 return rc; 225 } 226 227 return rc; 228 } 229 230 static enum pkcs11_rc get_default_value(enum pkcs11_attr_id id, void **value, 231 uint32_t *size) 232 { 233 /* should have been taken care of already */ 234 assert(!pkcs11_attr_is_boolean(id)); 235 236 if (id == PKCS11_CKA_PUBLIC_KEY_INFO) { 237 EMSG("Cannot provide default PUBLIC_KEY_INFO"); 238 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 239 } 240 241 /* All other attributes have an empty default value */ 242 *value = NULL; 243 *size = 0; 244 return PKCS11_CKR_OK; 245 } 246 247 static enum pkcs11_rc set_optional_attributes_with_def(struct obj_attrs **out, 248 struct obj_attrs *temp, 249 uint32_t const *bp, 250 size_t bp_count, 251 bool default_to_null) 252 { 253 enum pkcs11_rc rc = PKCS11_CKR_OK; 254 size_t n = 0; 255 256 for (n = 0; n < bp_count; n++) { 257 uint32_t size = 0; 258 void *value = NULL; 259 260 rc = get_attribute_ptr(temp, bp[n], &value, &size); 261 if (rc == PKCS11_RV_NOT_FOUND) { 262 if (default_to_null) { 263 rc = get_default_value(bp[n], &value, &size); 264 } else { 265 rc = PKCS11_CKR_OK; 266 continue; 267 } 268 } 269 if (rc) 270 return rc; 271 272 rc = add_attribute(out, bp[n], value, size); 273 if (rc) 274 return rc; 275 } 276 277 return rc; 278 } 279 280 static enum pkcs11_rc set_attributes_opt_or_null(struct obj_attrs **out, 281 struct obj_attrs *temp, 282 uint32_t const *bp, 283 size_t bp_count) 284 { 285 return set_optional_attributes_with_def(out, temp, bp, bp_count, true); 286 } 287 288 static enum pkcs11_rc set_optional_attributes(struct obj_attrs **out, 289 struct obj_attrs *temp, 290 uint32_t const *bp, 291 size_t bp_count) 292 { 293 return set_optional_attributes_with_def(out, temp, bp, bp_count, false); 294 } 295 296 /* 297 * Below are listed the mandated or optional expected attributes for 298 * PKCS#11 storage objects. 299 * 300 * Note: boolprops (mandated boolean attributes) PKCS11_CKA_ALWAYS_SENSITIVE, 301 * and PKCS11_CKA_NEVER_EXTRACTABLE are set by the token, not provided 302 * in the client template. 303 */ 304 305 /* PKCS#11 specification for any object (session/token) of the storage */ 306 static const uint32_t any_object_boolprops[] = { 307 PKCS11_CKA_TOKEN, PKCS11_CKA_PRIVATE, 308 PKCS11_CKA_MODIFIABLE, PKCS11_CKA_COPYABLE, PKCS11_CKA_DESTROYABLE, 309 }; 310 311 static const uint32_t any_object_opt_or_null[] = { 312 PKCS11_CKA_LABEL, 313 }; 314 315 /* PKCS#11 specification for raw data object (+any_object_xxx) */ 316 const uint32_t raw_data_opt_or_null[] = { 317 PKCS11_CKA_OBJECT_ID, PKCS11_CKA_APPLICATION, PKCS11_CKA_VALUE, 318 }; 319 320 /* PKCS#11 specification for any key object (+any_object_xxx) */ 321 static const uint32_t any_key_boolprops[] = { 322 PKCS11_CKA_DERIVE, 323 }; 324 325 static const uint32_t any_key_opt_or_null[] = { 326 PKCS11_CKA_ID, 327 PKCS11_CKA_START_DATE, PKCS11_CKA_END_DATE, 328 }; 329 330 static const uint32_t any_key_optional[] = { 331 PKCS11_CKA_ALLOWED_MECHANISMS, 332 }; 333 334 /* PKCS#11 specification for any symmetric key (+any_key_xxx) */ 335 static const uint32_t symm_key_boolprops[] = { 336 PKCS11_CKA_ENCRYPT, PKCS11_CKA_DECRYPT, 337 PKCS11_CKA_SIGN, PKCS11_CKA_VERIFY, 338 PKCS11_CKA_WRAP, PKCS11_CKA_UNWRAP, 339 PKCS11_CKA_SENSITIVE, PKCS11_CKA_EXTRACTABLE, 340 PKCS11_CKA_WRAP_WITH_TRUSTED, PKCS11_CKA_TRUSTED, 341 }; 342 343 static const uint32_t symm_key_opt_or_null[] = { 344 PKCS11_CKA_WRAP_TEMPLATE, PKCS11_CKA_UNWRAP_TEMPLATE, 345 PKCS11_CKA_DERIVE_TEMPLATE, 346 PKCS11_CKA_VALUE, PKCS11_CKA_VALUE_LEN, 347 }; 348 349 /* PKCS#11 specification for any asymmetric public key (+any_key_xxx) */ 350 static const uint32_t public_key_boolprops[] = { 351 PKCS11_CKA_ENCRYPT, PKCS11_CKA_VERIFY, PKCS11_CKA_VERIFY_RECOVER, 352 PKCS11_CKA_WRAP, 353 PKCS11_CKA_TRUSTED, 354 }; 355 356 static const uint32_t public_key_mandated[] = { 357 PKCS11_CKA_SUBJECT 358 }; 359 360 static const uint32_t public_key_opt_or_null[] = { 361 PKCS11_CKA_WRAP_TEMPLATE, PKCS11_CKA_PUBLIC_KEY_INFO, 362 }; 363 364 /* PKCS#11 specification for any asymmetric private key (+any_key_xxx) */ 365 static const uint32_t private_key_boolprops[] = { 366 PKCS11_CKA_DECRYPT, PKCS11_CKA_SIGN, PKCS11_CKA_SIGN_RECOVER, 367 PKCS11_CKA_UNWRAP, 368 PKCS11_CKA_SENSITIVE, PKCS11_CKA_EXTRACTABLE, 369 PKCS11_CKA_WRAP_WITH_TRUSTED, PKCS11_CKA_ALWAYS_AUTHENTICATE, 370 }; 371 372 static const uint32_t private_key_mandated[] = { 373 PKCS11_CKA_SUBJECT 374 }; 375 376 static const uint32_t private_key_opt_or_null[] = { 377 PKCS11_CKA_UNWRAP_TEMPLATE, PKCS11_CKA_PUBLIC_KEY_INFO, 378 }; 379 380 /* PKCS#11 specification for any RSA key (+public/private_key_xxx) */ 381 static const uint32_t rsa_public_key_mandated[] = { 382 PKCS11_CKA_MODULUS_BITS, 383 }; 384 385 static const uint32_t rsa_public_key_opt_or_null[] = { 386 PKCS11_CKA_MODULUS, PKCS11_CKA_PUBLIC_EXPONENT, 387 }; 388 389 static const uint32_t rsa_private_key_opt_or_null[] = { 390 PKCS11_CKA_MODULUS, PKCS11_CKA_PUBLIC_EXPONENT, 391 PKCS11_CKA_PRIVATE_EXPONENT, 392 PKCS11_CKA_PRIME_1, PKCS11_CKA_PRIME_2, 393 PKCS11_CKA_EXPONENT_1, PKCS11_CKA_EXPONENT_2, PKCS11_CKA_COEFFICIENT, 394 }; 395 396 /* PKCS#11 specification for any EC key (+public/private_key_xxx) */ 397 static const uint32_t ec_public_key_mandated[] = { 398 PKCS11_CKA_EC_PARAMS, 399 }; 400 401 static const uint32_t ec_public_key_opt_or_null[] = { 402 PKCS11_CKA_EC_POINT, 403 }; 404 405 static const uint32_t ec_private_key_mandated[] = { 406 PKCS11_CKA_EC_PARAMS, 407 }; 408 409 static const uint32_t ec_private_key_opt_or_null[] = { 410 PKCS11_CKA_VALUE, 411 }; 412 413 static enum pkcs11_rc create_storage_attributes(struct obj_attrs **out, 414 struct obj_attrs *temp) 415 { 416 enum pkcs11_class_id class = PKCS11_CKO_UNDEFINED_ID; 417 enum pkcs11_rc rc = PKCS11_CKR_OK; 418 419 rc = init_attributes_head(out); 420 if (rc) 421 return rc; 422 423 /* Object class is mandatory */ 424 class = get_class(temp); 425 if (class == PKCS11_CKO_UNDEFINED_ID) { 426 EMSG("Class attribute not found"); 427 428 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 429 } 430 rc = add_attribute(out, PKCS11_CKA_CLASS, &class, sizeof(uint32_t)); 431 if (rc) 432 return rc; 433 434 rc = set_mandatory_boolprops(out, temp, any_object_boolprops, 435 ARRAY_SIZE(any_object_boolprops)); 436 if (rc) 437 return rc; 438 439 return set_attributes_opt_or_null(out, temp, any_object_opt_or_null, 440 ARRAY_SIZE(any_object_opt_or_null)); 441 } 442 443 static enum pkcs11_rc create_genkey_attributes(struct obj_attrs **out, 444 struct obj_attrs *temp) 445 { 446 uint32_t type = PKCS11_CKO_UNDEFINED_ID; 447 enum pkcs11_rc rc = PKCS11_CKR_OK; 448 449 rc = create_storage_attributes(out, temp); 450 if (rc) 451 return rc; 452 453 type = get_key_type(temp); 454 if (type == PKCS11_CKK_UNDEFINED_ID) { 455 EMSG("Key type attribute not found"); 456 457 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 458 } 459 rc = add_attribute(out, PKCS11_CKA_KEY_TYPE, &type, sizeof(uint32_t)); 460 if (rc) 461 return rc; 462 463 rc = set_mandatory_boolprops(out, temp, any_key_boolprops, 464 ARRAY_SIZE(any_key_boolprops)); 465 if (rc) 466 return rc; 467 468 rc = set_attributes_opt_or_null(out, temp, any_key_opt_or_null, 469 ARRAY_SIZE(any_key_opt_or_null)); 470 if (rc) 471 return rc; 472 473 return set_optional_attributes(out, temp, any_key_optional, 474 ARRAY_SIZE(any_key_optional)); 475 476 } 477 478 static enum pkcs11_rc create_symm_key_attributes(struct obj_attrs **out, 479 struct obj_attrs *temp) 480 { 481 enum pkcs11_rc rc = PKCS11_CKR_OK; 482 483 assert(get_class(temp) == PKCS11_CKO_SECRET_KEY); 484 485 rc = create_genkey_attributes(out, temp); 486 if (rc) 487 return rc; 488 489 assert(get_class(*out) == PKCS11_CKO_SECRET_KEY); 490 491 switch (get_key_type(*out)) { 492 case PKCS11_CKK_GENERIC_SECRET: 493 case PKCS11_CKK_AES: 494 case PKCS11_CKK_MD5_HMAC: 495 case PKCS11_CKK_SHA_1_HMAC: 496 case PKCS11_CKK_SHA256_HMAC: 497 case PKCS11_CKK_SHA384_HMAC: 498 case PKCS11_CKK_SHA512_HMAC: 499 case PKCS11_CKK_SHA224_HMAC: 500 break; 501 default: 502 EMSG("Invalid key type %#"PRIx32"/%s", 503 get_key_type(*out), id2str_key_type(get_key_type(*out))); 504 505 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 506 } 507 508 rc = set_mandatory_boolprops(out, temp, symm_key_boolprops, 509 ARRAY_SIZE(symm_key_boolprops)); 510 if (rc) 511 return rc; 512 513 return set_attributes_opt_or_null(out, temp, symm_key_opt_or_null, 514 ARRAY_SIZE(symm_key_opt_or_null)); 515 } 516 517 static enum pkcs11_rc create_data_attributes(struct obj_attrs **out, 518 struct obj_attrs *temp) 519 { 520 enum pkcs11_rc rc = PKCS11_CKR_OK; 521 522 assert(get_class(temp) == PKCS11_CKO_DATA); 523 524 rc = create_storage_attributes(out, temp); 525 if (rc) 526 return rc; 527 528 assert(get_class(*out) == PKCS11_CKO_DATA); 529 530 return set_attributes_opt_or_null(out, temp, raw_data_opt_or_null, 531 ARRAY_SIZE(raw_data_opt_or_null)); 532 } 533 534 static enum pkcs11_rc create_pub_key_attributes(struct obj_attrs **out, 535 struct obj_attrs *temp) 536 { 537 uint32_t const *mandated = NULL; 538 uint32_t const *opt_or_null = NULL; 539 size_t mandated_count = 0; 540 size_t opt_or_null_count = 0; 541 enum pkcs11_rc rc = PKCS11_CKR_OK; 542 543 assert(get_class(temp) == PKCS11_CKO_PUBLIC_KEY); 544 545 rc = create_genkey_attributes(out, temp); 546 if (rc) 547 return rc; 548 549 assert(get_class(*out) == PKCS11_CKO_PUBLIC_KEY); 550 551 rc = set_mandatory_boolprops(out, temp, public_key_boolprops, 552 ARRAY_SIZE(public_key_boolprops)); 553 if (rc) 554 return rc; 555 556 rc = set_mandatory_attributes(out, temp, public_key_mandated, 557 ARRAY_SIZE(public_key_mandated)); 558 if (rc) 559 return rc; 560 561 rc = set_attributes_opt_or_null(out, temp, 562 public_key_opt_or_null, 563 ARRAY_SIZE(public_key_opt_or_null)); 564 if (rc) 565 return rc; 566 567 switch (get_key_type(*out)) { 568 case PKCS11_CKK_RSA: 569 mandated = rsa_public_key_mandated; 570 opt_or_null = rsa_public_key_opt_or_null; 571 mandated_count = ARRAY_SIZE(rsa_public_key_mandated); 572 opt_or_null_count = ARRAY_SIZE(rsa_public_key_opt_or_null); 573 break; 574 case PKCS11_CKK_EC: 575 mandated = ec_public_key_mandated; 576 opt_or_null = ec_public_key_opt_or_null; 577 mandated_count = ARRAY_SIZE(ec_public_key_mandated); 578 opt_or_null_count = ARRAY_SIZE(ec_public_key_opt_or_null); 579 break; 580 default: 581 EMSG("Invalid key type %#"PRIx32"/%s", 582 get_key_type(*out), id2str_key_type(get_key_type(*out))); 583 584 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 585 } 586 587 rc = set_mandatory_attributes(out, temp, mandated, mandated_count); 588 if (rc) 589 return rc; 590 591 return set_attributes_opt_or_null(out, temp, opt_or_null, 592 opt_or_null_count); 593 } 594 595 static enum pkcs11_rc create_priv_key_attributes(struct obj_attrs **out, 596 struct obj_attrs *temp) 597 { 598 uint32_t const *mandated = NULL; 599 uint32_t const *opt_or_null = NULL; 600 size_t mandated_count = 0; 601 size_t opt_or_null_count = 0; 602 enum pkcs11_rc rc = PKCS11_CKR_OK; 603 604 assert(get_class(temp) == PKCS11_CKO_PRIVATE_KEY); 605 606 rc = create_genkey_attributes(out, temp); 607 if (rc) 608 return rc; 609 610 assert(get_class(*out) == PKCS11_CKO_PRIVATE_KEY); 611 612 rc = set_mandatory_boolprops(out, temp, private_key_boolprops, 613 ARRAY_SIZE(private_key_boolprops)); 614 if (rc) 615 return rc; 616 617 rc = set_mandatory_attributes(out, temp, private_key_mandated, 618 ARRAY_SIZE(private_key_mandated)); 619 if (rc) 620 return rc; 621 622 rc = set_attributes_opt_or_null(out, temp, private_key_opt_or_null, 623 ARRAY_SIZE(private_key_opt_or_null)); 624 if (rc) 625 return rc; 626 627 switch (get_key_type(*out)) { 628 case PKCS11_CKK_RSA: 629 opt_or_null = rsa_private_key_opt_or_null; 630 opt_or_null_count = ARRAY_SIZE(rsa_private_key_opt_or_null); 631 break; 632 case PKCS11_CKK_EC: 633 mandated = ec_private_key_mandated; 634 opt_or_null = ec_private_key_opt_or_null; 635 mandated_count = ARRAY_SIZE(ec_private_key_mandated); 636 opt_or_null_count = ARRAY_SIZE(ec_private_key_opt_or_null); 637 break; 638 default: 639 EMSG("Invalid key type %#"PRIx32"/%s", 640 get_key_type(*out), id2str_key_type(get_key_type(*out))); 641 642 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 643 } 644 645 rc = set_mandatory_attributes(out, temp, mandated, mandated_count); 646 if (rc) 647 return rc; 648 649 return set_attributes_opt_or_null(out, temp, opt_or_null, 650 opt_or_null_count); 651 } 652 653 /* 654 * Create an attribute list for a new object from a template and a parent 655 * object (optional) for an object generation function (generate, copy, 656 * derive...). 657 * 658 * PKCS#11 directives on the supplied template and expected return value: 659 * - template has an invalid attribute ID: ATTRIBUTE_TYPE_INVALID 660 * - template has an invalid value for an attribute: ATTRIBUTE_VALID_INVALID 661 * - template has value for a read-only attribute: ATTRIBUTE_READ_ONLY 662 * - template+default+parent => still miss an attribute: TEMPLATE_INCONSISTENT 663 * 664 * INFO on PKCS11_CMD_COPY_OBJECT: 665 * - parent PKCS11_CKA_COPYIABLE=false => return ACTION_PROHIBITED. 666 * - template can specify PKCS11_CKA_TOKEN, PKCS11_CKA_PRIVATE, 667 * PKCS11_CKA_MODIFIABLE, PKCS11_CKA_DESTROYABLE. 668 * - SENSITIVE can change from false to true, not from true to false. 669 * - LOCAL is the parent LOCAL 670 */ 671 enum pkcs11_rc 672 create_attributes_from_template(struct obj_attrs **out, void *template, 673 size_t template_size, 674 struct obj_attrs *parent __unused, 675 enum processing_func function, 676 enum pkcs11_mechanism_id mecha __unused) 677 { 678 struct obj_attrs *temp = NULL; 679 struct obj_attrs *attrs = NULL; 680 enum pkcs11_rc rc = PKCS11_CKR_OK; 681 uint8_t local = 0; 682 uint8_t always_sensitive = 0; 683 uint8_t never_extract = 0; 684 uint32_t mechanism_id = PKCS11_CKM_UNDEFINED_ID; 685 686 #ifdef DEBUG /* Sanity: check function argument */ 687 trace_attributes_from_api_head("template", template, template_size); 688 switch (function) { 689 case PKCS11_FUNCTION_IMPORT: 690 break; 691 default: 692 TEE_Panic(TEE_ERROR_NOT_SUPPORTED); 693 } 694 #endif 695 696 rc = sanitize_client_object(&temp, template, template_size); 697 if (rc) 698 goto out; 699 700 /* If class/type not defined, match from mechanism */ 701 if (get_class(temp) == PKCS11_UNDEFINED_ID && 702 get_key_type(temp) == PKCS11_UNDEFINED_ID) { 703 EMSG("Unable to define class/type from mechanism"); 704 rc = PKCS11_CKR_TEMPLATE_INCOMPLETE; 705 goto out; 706 } 707 708 if (!sanitize_consistent_class_and_type(temp)) { 709 EMSG("Inconsistent class/type"); 710 rc = PKCS11_CKR_TEMPLATE_INCONSISTENT; 711 goto out; 712 } 713 714 switch (get_class(temp)) { 715 case PKCS11_CKO_DATA: 716 rc = create_data_attributes(&attrs, temp); 717 break; 718 case PKCS11_CKO_SECRET_KEY: 719 rc = create_symm_key_attributes(&attrs, temp); 720 break; 721 case PKCS11_CKO_PUBLIC_KEY: 722 rc = create_pub_key_attributes(&attrs, temp); 723 break; 724 case PKCS11_CKO_PRIVATE_KEY: 725 rc = create_priv_key_attributes(&attrs, temp); 726 break; 727 default: 728 DMSG("Invalid object class %#"PRIx32"/%s", 729 get_class(temp), id2str_class(get_class(temp))); 730 731 rc = PKCS11_CKR_TEMPLATE_INCONSISTENT; 732 break; 733 } 734 if (rc) 735 goto out; 736 737 if (get_attribute(attrs, PKCS11_CKA_LOCAL, NULL, NULL) != 738 PKCS11_RV_NOT_FOUND) 739 goto out; 740 741 if (get_attribute(attrs, PKCS11_CKA_KEY_GEN_MECHANISM, NULL, NULL) != 742 PKCS11_RV_NOT_FOUND) 743 goto out; 744 745 switch (function) { 746 case PKCS11_FUNCTION_IMPORT: 747 default: 748 local = PKCS11_FALSE; 749 break; 750 } 751 rc = add_attribute(&attrs, PKCS11_CKA_LOCAL, &local, sizeof(local)); 752 if (rc) 753 goto out; 754 755 switch (get_class(attrs)) { 756 case PKCS11_CKO_SECRET_KEY: 757 case PKCS11_CKO_PRIVATE_KEY: 758 case PKCS11_CKO_PUBLIC_KEY: 759 always_sensitive = PKCS11_FALSE; 760 never_extract = PKCS11_FALSE; 761 762 rc = add_attribute(&attrs, PKCS11_CKA_ALWAYS_SENSITIVE, 763 &always_sensitive, sizeof(always_sensitive)); 764 if (rc) 765 goto out; 766 767 rc = add_attribute(&attrs, PKCS11_CKA_NEVER_EXTRACTABLE, 768 &never_extract, sizeof(never_extract)); 769 if (rc) 770 goto out; 771 772 /* Keys mandate attribute PKCS11_CKA_KEY_GEN_MECHANISM */ 773 mechanism_id = PKCS11_CK_UNAVAILABLE_INFORMATION; 774 rc = add_attribute(&attrs, PKCS11_CKA_KEY_GEN_MECHANISM, 775 &mechanism_id, sizeof(mechanism_id)); 776 if (rc) 777 goto out; 778 break; 779 780 default: 781 break; 782 } 783 784 *out = attrs; 785 786 #ifdef DEBUG 787 trace_attributes("object", attrs); 788 #endif 789 790 out: 791 TEE_Free(temp); 792 if (rc) 793 TEE_Free(attrs); 794 795 return rc; 796 } 797 798 static enum pkcs11_rc check_attrs_misc_integrity(struct obj_attrs *head) 799 { 800 if (get_bool(head, PKCS11_CKA_NEVER_EXTRACTABLE) && 801 get_bool(head, PKCS11_CKA_EXTRACTABLE)) { 802 DMSG("Never/Extractable attributes mismatch %d/%d", 803 get_bool(head, PKCS11_CKA_NEVER_EXTRACTABLE), 804 get_bool(head, PKCS11_CKA_EXTRACTABLE)); 805 806 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 807 } 808 809 if (get_bool(head, PKCS11_CKA_ALWAYS_SENSITIVE) && 810 !get_bool(head, PKCS11_CKA_SENSITIVE)) { 811 DMSG("Sensitive/always attributes mismatch %d/%d", 812 get_bool(head, PKCS11_CKA_SENSITIVE), 813 get_bool(head, PKCS11_CKA_ALWAYS_SENSITIVE)); 814 815 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 816 } 817 818 return PKCS11_CKR_OK; 819 } 820 821 /* 822 * Check access to object against authentication to token 823 */ 824 enum pkcs11_rc check_access_attrs_against_token(struct pkcs11_session *session, 825 struct obj_attrs *head) 826 { 827 bool private = true; 828 829 switch (get_class(head)) { 830 case PKCS11_CKO_SECRET_KEY: 831 case PKCS11_CKO_PUBLIC_KEY: 832 case PKCS11_CKO_DATA: 833 private = get_bool(head, PKCS11_CKA_PRIVATE); 834 break; 835 case PKCS11_CKO_PRIVATE_KEY: 836 break; 837 default: 838 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 839 } 840 841 if (private && pkcs11_session_is_public(session)) { 842 DMSG("Private object access from a public session"); 843 844 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 845 } 846 847 return PKCS11_CKR_OK; 848 } 849 850 /* 851 * Check the attributes of a to-be-created object matches the token state 852 */ 853 enum pkcs11_rc check_created_attrs_against_token(struct pkcs11_session *session, 854 struct obj_attrs *head) 855 { 856 enum pkcs11_rc rc = PKCS11_CKR_OK; 857 858 rc = check_attrs_misc_integrity(head); 859 if (rc) 860 return rc; 861 862 if (get_bool(head, PKCS11_CKA_TRUSTED) && 863 !pkcs11_session_is_so(session)) { 864 DMSG("Can't create trusted object"); 865 866 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 867 } 868 869 if (get_bool(head, PKCS11_CKA_TOKEN) && 870 !pkcs11_session_is_read_write(session)) { 871 DMSG("Can't create persistent object"); 872 873 return PKCS11_CKR_SESSION_READ_ONLY; 874 } 875 876 /* 877 * TODO: START_DATE and END_DATE: complies with current time? 878 */ 879 return PKCS11_CKR_OK; 880 } 881 882 #define DMSG_BAD_BBOOL(attr, proc, head) \ 883 do { \ 884 uint32_t __maybe_unused _attr = (attr); \ 885 uint8_t __maybe_unused _bvalue = 0; \ 886 enum pkcs11_rc __maybe_unused _rc = PKCS11_CKR_OK; \ 887 \ 888 _rc = get_attribute((head), _attr, &_bvalue, NULL); \ 889 DMSG("%s issue for %s: %sfound, value %"PRIu8, \ 890 id2str_attr(_attr), id2str_proc((proc)), \ 891 _rc ? "not " : "", _bvalue); \ 892 } while (0) 893 894 static bool __maybe_unused check_attr_bval(uint32_t proc_id __maybe_unused, 895 struct obj_attrs *head, 896 uint32_t attribute, bool val) 897 { 898 uint8_t bbool = 0; 899 uint32_t sz = sizeof(bbool); 900 901 if (!get_attribute(head, attribute, &bbool, &sz) && !!bbool == val) 902 return true; 903 904 DMSG_BAD_BBOOL(attribute, proc_id, head); 905 return false; 906 } 907 908 /* 909 * Check the attributes of a new secret match the processing/mechanism 910 * used to create it. 911 * 912 * @proc_id - PKCS11_CKM_xxx 913 * @head - head of the attributes of the to-be-created object. 914 */ 915 enum pkcs11_rc check_created_attrs_against_processing(uint32_t proc_id, 916 struct obj_attrs *head) 917 { 918 /* 919 * Processings that do not create secrets are not expected to call 920 * this function which would panic. 921 */ 922 switch (proc_id) { 923 case PKCS11_PROCESSING_IMPORT: 924 assert(check_attr_bval(proc_id, head, PKCS11_CKA_LOCAL, false)); 925 break; 926 default: 927 TEE_Panic(proc_id); 928 break; 929 } 930 931 return PKCS11_CKR_OK; 932 } 933 934 static void get_key_min_max_sizes(enum pkcs11_key_type key_type, 935 uint32_t *min_key_size, 936 uint32_t *max_key_size) 937 { 938 enum pkcs11_mechanism_id mechanism = PKCS11_CKM_UNDEFINED_ID; 939 940 switch (key_type) { 941 case PKCS11_CKK_AES: 942 mechanism = PKCS11_CKM_AES_KEY_GEN; 943 break; 944 default: 945 TEE_Panic(key_type); 946 break; 947 } 948 949 mechanism_supported_key_sizes(mechanism, min_key_size, 950 max_key_size); 951 } 952 953 enum pkcs11_rc check_created_attrs(struct obj_attrs *key1, 954 struct obj_attrs *key2) 955 { 956 enum pkcs11_rc rc = PKCS11_CKR_OK; 957 struct obj_attrs *secret = NULL; 958 uint32_t max_key_size = 0; 959 uint32_t min_key_size = 0; 960 uint32_t key_length = 0; 961 962 switch (get_class(key1)) { 963 case PKCS11_CKO_SECRET_KEY: 964 secret = key1; 965 break; 966 default: 967 return PKCS11_CKR_ATTRIBUTE_VALUE_INVALID; 968 } 969 970 if (key2) 971 return PKCS11_CKR_ATTRIBUTE_VALUE_INVALID; 972 973 if (secret) { 974 switch (get_key_type(secret)) { 975 case PKCS11_CKK_AES: 976 case PKCS11_CKK_GENERIC_SECRET: 977 case PKCS11_CKK_MD5_HMAC: 978 case PKCS11_CKK_SHA_1_HMAC: 979 case PKCS11_CKK_SHA224_HMAC: 980 case PKCS11_CKK_SHA256_HMAC: 981 case PKCS11_CKK_SHA384_HMAC: 982 case PKCS11_CKK_SHA512_HMAC: 983 break; 984 default: 985 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 986 } 987 988 /* Get key size */ 989 rc = get_u32_attribute(secret, PKCS11_CKA_VALUE_LEN, 990 &key_length); 991 if (rc) 992 return PKCS11_CKR_TEMPLATE_INCONSISTENT; 993 } 994 995 get_key_min_max_sizes(get_key_type(key1), &min_key_size, &max_key_size); 996 if (key_length < min_key_size || key_length > max_key_size) { 997 EMSG("Length %"PRIu32" vs range [%"PRIu32" %"PRIu32"]", 998 key_length, min_key_size, max_key_size); 999 1000 return PKCS11_CKR_KEY_SIZE_RANGE; 1001 } 1002 1003 return PKCS11_CKR_OK; 1004 } 1005 1006 /* Check processing ID against attribute ALLOWED_MECHANISMS if any */ 1007 static bool parent_key_complies_allowed_processings(uint32_t proc_id, 1008 struct obj_attrs *head) 1009 { 1010 char *attr = NULL; 1011 uint32_t size = 0; 1012 uint32_t proc = 0; 1013 size_t count = 0; 1014 enum pkcs11_rc rc = PKCS11_CKR_GENERAL_ERROR; 1015 1016 rc = get_attribute_ptr(head, PKCS11_CKA_ALLOWED_MECHANISMS, 1017 (void *)&attr, &size); 1018 if (rc == PKCS11_RV_NOT_FOUND) 1019 return true; 1020 if (rc) { 1021 EMSG("unexpected attributes state"); 1022 TEE_Panic(TEE_ERROR_BAD_STATE); 1023 } 1024 1025 for (count = size / sizeof(uint32_t); count; count--) { 1026 TEE_MemMove(&proc, attr, sizeof(uint32_t)); 1027 attr += sizeof(uint32_t); 1028 1029 if (proc == proc_id) 1030 return true; 1031 } 1032 1033 DMSG("can't find %s in allowed list", id2str_proc(proc_id)); 1034 return false; 1035 } 1036 1037 static enum pkcs11_attr_id func_to_attr(enum processing_func func) 1038 { 1039 switch (func) { 1040 case PKCS11_FUNCTION_ENCRYPT: 1041 return PKCS11_CKA_ENCRYPT; 1042 case PKCS11_FUNCTION_DECRYPT: 1043 return PKCS11_CKA_DECRYPT; 1044 case PKCS11_FUNCTION_SIGN: 1045 return PKCS11_CKA_SIGN; 1046 case PKCS11_FUNCTION_VERIFY: 1047 return PKCS11_CKA_VERIFY; 1048 case PKCS11_FUNCTION_WRAP: 1049 return PKCS11_CKA_WRAP; 1050 case PKCS11_FUNCTION_UNWRAP: 1051 return PKCS11_CKA_UNWRAP; 1052 case PKCS11_FUNCTION_DERIVE: 1053 return PKCS11_CKA_DERIVE; 1054 default: 1055 return PKCS11_CKA_UNDEFINED_ID; 1056 } 1057 } 1058 1059 enum pkcs11_rc 1060 check_parent_attrs_against_processing(enum pkcs11_mechanism_id proc_id, 1061 enum processing_func function, 1062 struct obj_attrs *head) 1063 { 1064 enum pkcs11_class_id key_class = get_class(head); 1065 enum pkcs11_key_type key_type = get_key_type(head); 1066 enum pkcs11_attr_id attr = func_to_attr(function); 1067 1068 if (!get_bool(head, attr)) { 1069 DMSG("%s not permitted", id2str_attr(attr)); 1070 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 1071 } 1072 1073 /* Check processing complies with parent key family */ 1074 switch (proc_id) { 1075 case PKCS11_CKM_AES_ECB: 1076 case PKCS11_CKM_AES_CBC: 1077 case PKCS11_CKM_AES_CBC_PAD: 1078 case PKCS11_CKM_AES_CTS: 1079 case PKCS11_CKM_AES_CTR: 1080 if (key_class == PKCS11_CKO_SECRET_KEY && 1081 key_type == PKCS11_CKK_AES) 1082 break; 1083 1084 DMSG("%s invalid key %s/%s", id2str_proc(proc_id), 1085 id2str_class(key_class), id2str_key_type(key_type)); 1086 1087 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 1088 1089 default: 1090 DMSG("Invalid processing %#"PRIx32"/%s", proc_id, 1091 id2str_proc(proc_id)); 1092 1093 return PKCS11_CKR_MECHANISM_INVALID; 1094 } 1095 1096 if (!parent_key_complies_allowed_processings(proc_id, head)) { 1097 DMSG("Allowed mechanism failed"); 1098 return PKCS11_CKR_KEY_FUNCTION_NOT_PERMITTED; 1099 } 1100 1101 return PKCS11_CKR_OK; 1102 } 1103