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