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