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