1 /* 2 * The Initial Developer of the Original Code is International 3 * Business Machines Corporation. Portions created by IBM 4 * Corporation are Copyright (C) 2005 International Business 5 * Machines Corporation. All Rights Reserved. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the Common Public License as published by 9 * IBM Corporation; either version 1 of the License, or (at your option) 10 * any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * Common Public License for more details. 16 * 17 * You should have received a copy of the Common Public License 18 * along with this program; if not, a copy can be viewed at 19 * http://www.opensource.org/licenses/cpl1.0.php. 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright 2012 Milan Jurik. All rights reserved. 25 * Copyright (c) 2016 by Delphix. All rights reserved. 26 * Copyright 2018 Jason King 27 */ 28 29 #include <pthread.h> 30 #include <string.h> 31 32 #include <sys/types.h> 33 #include <sys/stat.h> 34 #include <uuid/uuid.h> 35 #include <fcntl.h> 36 #include <errno.h> 37 #include <pwd.h> 38 #include <syslog.h> 39 40 #include <sys/crypto/common.h> /* For CRYPTO_BYTES2BITS */ 41 #include <rsa_impl.h> 42 #include <padding.h> 43 44 #include <tss/platform.h> 45 #include <tss/tss_defines.h> 46 #include <tss/tss_typedef.h> 47 #include <tss/tss_structs.h> 48 #include <tss/tss_error.h> 49 #include <tss/tcs_error.h> 50 #include <tss/tspi.h> 51 #include <trousers/trousers.h> 52 53 #include "tpmtok_int.h" 54 #include "tpmtok_defs.h" 55 56 #define MAX_RSA_KEYLENGTH 512 57 58 extern void stlogit(char *fmt, ...); 59 60 CK_RV token_rng(TSS_HCONTEXT, CK_BYTE *, CK_ULONG); 61 int tok_slot2local(CK_SLOT_ID); 62 CK_RV token_specific_session(CK_SLOT_ID); 63 CK_RV token_specific_final(TSS_HCONTEXT); 64 65 CK_RV 66 token_specific_rsa_decrypt( 67 TSS_HCONTEXT, 68 CK_BYTE *, 69 CK_ULONG, 70 CK_BYTE *, 71 CK_ULONG *, 72 OBJECT *); 73 74 CK_RV 75 token_specific_rsa_encrypt( 76 TSS_HCONTEXT, 77 CK_BYTE *, 78 CK_ULONG, 79 CK_BYTE *, 80 CK_ULONG *, 81 OBJECT *); 82 83 CK_RV 84 token_specific_rsa_sign( 85 TSS_HCONTEXT, 86 CK_BYTE *, 87 CK_ULONG, 88 CK_BYTE *, 89 CK_ULONG *, 90 OBJECT *); 91 92 CK_RV 93 token_specific_rsa_verify(TSS_HCONTEXT, CK_BYTE *, 94 CK_ULONG, CK_BYTE *, CK_ULONG, OBJECT *); 95 96 CK_RV 97 token_specific_rsa_generate_keypair(TSS_HCONTEXT, 98 TEMPLATE *, 99 TEMPLATE *); 100 101 CK_RV 102 token_specific_sha_init(DIGEST_CONTEXT *); 103 104 CK_RV 105 token_specific_sha_update(DIGEST_CONTEXT *, 106 CK_BYTE *, 107 CK_ULONG); 108 109 CK_RV 110 token_specific_sha_final(DIGEST_CONTEXT *, 111 CK_BYTE *, 112 CK_ULONG *); 113 114 CK_RV token_specific_login(TSS_HCONTEXT, CK_USER_TYPE, CK_CHAR_PTR, CK_ULONG); 115 CK_RV token_specific_logout(TSS_HCONTEXT); 116 CK_RV token_specific_init_pin(TSS_HCONTEXT, CK_CHAR_PTR, CK_ULONG); 117 CK_RV token_specific_set_pin(ST_SESSION_HANDLE, CK_CHAR_PTR, 118 CK_ULONG, CK_CHAR_PTR, CK_ULONG); 119 CK_RV token_specific_verify_so_pin(TSS_HCONTEXT, CK_CHAR_PTR, CK_ULONG); 120 121 static CK_RV 122 token_specific_init(char *, CK_SLOT_ID, TSS_HCONTEXT *); 123 124 struct token_specific_struct token_specific = { 125 "TPM_Debug", 126 &token_specific_init, 127 NULL, 128 &token_rng, 129 &token_specific_session, 130 &token_specific_final, 131 &token_specific_rsa_decrypt, 132 &token_specific_rsa_encrypt, 133 &token_specific_rsa_sign, 134 &token_specific_rsa_verify, 135 &token_specific_rsa_generate_keypair, 136 NULL, 137 NULL, 138 NULL, 139 &token_specific_login, 140 &token_specific_logout, 141 &token_specific_init_pin, 142 &token_specific_set_pin, 143 &token_specific_verify_so_pin 144 }; 145 146 /* The context we'll use globally to connect to the TSP */ 147 148 /* TSP key handles */ 149 TSS_HKEY hPublicRootKey = NULL_HKEY; 150 TSS_HKEY hPublicLeafKey = NULL_HKEY; 151 TSS_HKEY hPrivateRootKey = NULL_HKEY; 152 TSS_HKEY hPrivateLeafKey = NULL_HKEY; 153 154 TSS_UUID publicRootKeyUUID; 155 TSS_UUID publicLeafKeyUUID; 156 TSS_UUID privateRootKeyUUID; 157 TSS_UUID privateLeafKeyUUID; 158 159 /* TSP policy handles */ 160 TSS_HPOLICY hDefaultPolicy = NULL_HPOLICY; 161 162 /* PKCS#11 key handles */ 163 int not_initialized = 0; 164 165 CK_BYTE current_user_pin_sha[SHA1_DIGEST_LENGTH]; 166 CK_BYTE current_so_pin_sha[SHA1_DIGEST_LENGTH]; 167 168 static TPM_CAP_VERSION_INFO tpmvinfo; 169 170 static CK_RV 171 verify_user_pin(TSS_HCONTEXT, CK_BYTE *); 172 173 static TSS_RESULT 174 tss_assign_secret_key_policy(TSS_HCONTEXT, TSS_FLAG, TSS_HKEY, CK_CHAR *); 175 176 static TSS_RESULT 177 set_legacy_key_params(TSS_HKEY); 178 179 static void 180 local_uuid_clear(TSS_UUID *uuid) 181 { 182 if (uuid == NULL) 183 return; 184 (void) memset(uuid, 0, sizeof (TSS_UUID)); 185 } 186 187 188 /* convert from TSS_UUID to uuid_t */ 189 static void 190 tss_uuid_convert_from(TSS_UUID *uu, uuid_t ptr) 191 { 192 uint_t tmp; 193 uchar_t *out = ptr; 194 195 tmp = ntohl(uu->ulTimeLow); 196 out[3] = (uchar_t)tmp; 197 tmp >>= 8; 198 out[2] = (uchar_t)tmp; 199 tmp >>= 8; 200 out[1] = (uchar_t)tmp; 201 tmp >>= 8; 202 out[0] = (uchar_t)tmp; 203 204 tmp = ntohs(uu->usTimeMid); 205 out[5] = (uchar_t)tmp; 206 tmp >>= 8; 207 out[4] = (uchar_t)tmp; 208 209 tmp = ntohs(uu->usTimeHigh); 210 out[7] = (uchar_t)tmp; 211 tmp >>= 8; 212 out[6] = (uchar_t)tmp; 213 214 tmp = uu->bClockSeqHigh; 215 out[8] = (uchar_t)tmp; 216 tmp = uu->bClockSeqLow; 217 out[9] = (uchar_t)tmp; 218 219 (void) memcpy(out+10, uu->rgbNode, 6); 220 } 221 222 /* convert from uuid_t to TSS_UUID */ 223 static void 224 tss_uuid_convert_to(TSS_UUID *uuid, uuid_t in) 225 { 226 uchar_t *ptr; 227 uint32_t ltmp; 228 uint16_t stmp; 229 230 ptr = in; 231 232 ltmp = *ptr++; 233 ltmp = (ltmp << 8) | *ptr++; 234 ltmp = (ltmp << 8) | *ptr++; 235 ltmp = (ltmp << 8) | *ptr++; 236 uuid->ulTimeLow = ntohl(ltmp); 237 238 stmp = *ptr++; 239 stmp = (stmp << 8) | *ptr++; 240 uuid->usTimeMid = ntohs(stmp); 241 242 stmp = *ptr++; 243 stmp = (stmp << 8) | *ptr++; 244 uuid->usTimeHigh = ntohs(stmp); 245 246 uuid->bClockSeqHigh = *ptr++; 247 248 uuid->bClockSeqLow = *ptr++; 249 250 (void) memcpy(uuid->rgbNode, ptr, 6); 251 } 252 253 static void 254 local_uuid_copy(TSS_UUID *dst, TSS_UUID *src) 255 { 256 uuid_t udst, usrc; 257 258 tss_uuid_convert_from(dst, udst); 259 tss_uuid_convert_from(src, usrc); 260 261 uuid_copy(udst, usrc); 262 263 tss_uuid_convert_to(dst, udst); 264 } 265 266 static void 267 local_uuid_generate(TSS_UUID *uu) 268 { 269 uuid_t newuuid; 270 271 uuid_generate(newuuid); 272 273 tss_uuid_convert_to(uu, newuuid); 274 } 275 276 static int 277 local_copy_file(char *dst, char *src) 278 { 279 FILE *fdest, *fsrc; 280 char line[BUFSIZ]; 281 282 fdest = fopen(dst, "w"); 283 if (fdest == NULL) 284 return (-1); 285 286 fsrc = fopen(src, "r"); 287 if (fsrc == NULL) { 288 (void) fclose(fdest); 289 return (-1); 290 } 291 292 while (fread(line, sizeof (line), 1, fsrc)) 293 (void) fprintf(fdest, "%s\n", line); 294 (void) fclose(fsrc); 295 (void) fclose(fdest); 296 return (0); 297 } 298 299 static int 300 remove_uuid(char *keyname) 301 { 302 int ret = 0; 303 FILE *fp, *newfp; 304 char fname[MAXPATHLEN]; 305 char line[BUFSIZ], key[BUFSIZ], idstr[BUFSIZ]; 306 char *tmpfname; 307 char *p = get_tpm_keystore_path(); 308 309 if (p == NULL) 310 return (-1); 311 312 (void) snprintf(fname, sizeof (fname), 313 "%s/%s", p, TPMTOK_UUID_INDEX_FILENAME); 314 315 fp = fopen(fname, "r"); 316 if (fp == NULL) { 317 return (-1); 318 } 319 320 tmpfname = tempnam("/tmp", "tpmtok"); 321 newfp = fopen(tmpfname, "w+"); 322 if (newfp == NULL) { 323 free(tmpfname); 324 (void) fclose(fp); 325 return (-1); 326 } 327 328 while (!feof(fp)) { 329 (void) fgets(line, sizeof (line), fp); 330 if (sscanf(line, "%1024s %1024s", key, idstr) == 2) { 331 if (strcmp(key, keyname)) 332 (void) fprintf(newfp, "%s\n", line); 333 } 334 } 335 336 (void) fclose(fp); 337 (void) fclose(newfp); 338 if (local_copy_file(fname, tmpfname) == 0) 339 (void) unlink(tmpfname); 340 341 free(tmpfname); 342 343 return (ret); 344 } 345 346 static int 347 find_uuid(char *keyname, TSS_UUID *uu) 348 { 349 int ret = 0, found = 0; 350 FILE *fp = NULL; 351 char fname[MAXPATHLEN]; 352 char line[BUFSIZ], key[BUFSIZ], idstr[BUFSIZ]; 353 uuid_t uuid; 354 char *p = get_tpm_keystore_path(); 355 356 if (p == NULL) 357 return (-1); 358 359 tss_uuid_convert_from(uu, uuid); 360 361 (void) snprintf(fname, sizeof (fname), 362 "%s/%s", p, TPMTOK_UUID_INDEX_FILENAME); 363 364 /* Open UUID Index file */ 365 fp = fopen(fname, "r"); 366 if (fp == NULL) { 367 if (errno == ENOENT) { 368 /* initialize the file */ 369 fp = fopen(fname, "w"); 370 if (fp != NULL) 371 (void) fclose(fp); 372 } 373 return (-1); 374 } 375 376 while (!feof(fp)) { 377 (void) fgets(line, sizeof (line), fp); 378 if (sscanf(line, "%1024s %1024s", key, idstr) == 2) { 379 if (strcmp(key, keyname) == 0) { 380 ret = uuid_parse(idstr, uuid); 381 if (ret == 0) { 382 found = 1; 383 tss_uuid_convert_to(uu, 384 uuid); 385 } 386 break; 387 } 388 } 389 } 390 (void) fclose(fp); 391 392 if (!found) 393 ret = -1; 394 return (ret); 395 } 396 397 static int 398 local_uuid_is_null(TSS_UUID *uu) 399 { 400 uuid_t uuid; 401 int nulluuid; 402 403 tss_uuid_convert_from(uu, uuid); 404 405 nulluuid = uuid_is_null(uuid); 406 return (nulluuid); 407 } 408 409 static int 410 add_uuid(char *keyname, TSS_UUID *uu) 411 { 412 FILE *fp = NULL; 413 char fname[MAXPATHLEN]; 414 char idstr[BUFSIZ]; 415 uuid_t uuid; 416 char *p = get_tpm_keystore_path(); 417 418 if (p == NULL) 419 return (-1); 420 421 tss_uuid_convert_from(uu, uuid); 422 423 if (uuid_is_null(uuid)) 424 return (-1); 425 426 uuid_unparse(uuid, idstr); 427 428 (void) snprintf(fname, sizeof (fname), 429 "%s/%s", p, TPMTOK_UUID_INDEX_FILENAME); 430 431 fp = fopen(fname, "a"); 432 if (fp == NULL) 433 return (-1); 434 435 (void) fprintf(fp, "%s %s\n", keyname, idstr); 436 (void) fclose(fp); 437 438 return (0); 439 } 440 441 442 static UINT32 443 util_get_keysize_flag(CK_ULONG size) 444 { 445 switch (size) { 446 case 512: 447 return (TSS_KEY_SIZE_512); 448 case 1024: 449 return (TSS_KEY_SIZE_1024); 450 case 2048: 451 return (TSS_KEY_SIZE_2048); 452 default: 453 break; 454 } 455 456 return (0); 457 } 458 459 /* make sure the public exponent attribute is 65537 */ 460 static CK_ULONG 461 util_check_public_exponent(TEMPLATE *tmpl) 462 { 463 CK_BBOOL flag; 464 CK_ATTRIBUTE *publ_exp_attr; 465 CK_BYTE pubexp_bytes[] = { 1, 0, 1 }; 466 CK_ULONG publ_exp, rc = 1; 467 468 flag = template_attribute_find(tmpl, CKA_PUBLIC_EXPONENT, 469 &publ_exp_attr); 470 if (!flag) { 471 LogError1("Couldn't find public exponent attribute"); 472 return (CKR_TEMPLATE_INCOMPLETE); 473 } 474 475 switch (publ_exp_attr->ulValueLen) { 476 case 3: 477 rc = memcmp(pubexp_bytes, publ_exp_attr->pValue, 3); 478 break; 479 case sizeof (CK_ULONG): 480 publ_exp = *((CK_ULONG *)publ_exp_attr->pValue); 481 if (publ_exp == 65537) 482 rc = 0; 483 break; 484 default: 485 break; 486 } 487 488 return (rc); 489 } 490 491 TSS_RESULT 492 set_public_modulus(TSS_HCONTEXT hContext, TSS_HKEY hKey, 493 unsigned long size_n, unsigned char *n) 494 { 495 UINT64 offset; 496 UINT32 blob_size; 497 BYTE *blob, pub_blob[1024]; 498 TCPA_PUBKEY pub_key; 499 TSS_RESULT result; 500 501 /* Get the TCPA_PUBKEY blob from the key object. */ 502 result = Tspi_GetAttribData(hKey, TSS_TSPATTRIB_KEY_BLOB, 503 TSS_TSPATTRIB_KEYBLOB_PUBLIC_KEY, &blob_size, &blob); 504 if (result != TSS_SUCCESS) { 505 stlogit("Tspi_GetAttribData failed: rc=0x%0x - %s\n", 506 result, Trspi_Error_String(result)); 507 return (result); 508 } 509 510 offset = 0; 511 result = Trspi_UnloadBlob_PUBKEY(&offset, blob, &pub_key); 512 if (result != TSS_SUCCESS) { 513 stlogit("Trspi_UnloadBlob_PUBKEY failed: rc=0x%0x - %s\n", 514 result, Trspi_Error_String(result)); 515 return (result); 516 } 517 518 Tspi_Context_FreeMemory(hContext, blob); 519 /* Free the first dangling reference, putting 'n' in its place */ 520 free(pub_key.pubKey.key); 521 pub_key.pubKey.keyLength = size_n; 522 pub_key.pubKey.key = n; 523 524 offset = 0; 525 Trspi_LoadBlob_PUBKEY(&offset, pub_blob, &pub_key); 526 527 /* Free the second dangling reference */ 528 free(pub_key.algorithmParms.parms); 529 530 /* set the public key data in the TSS object */ 531 result = Tspi_SetAttribData(hKey, TSS_TSPATTRIB_KEY_BLOB, 532 TSS_TSPATTRIB_KEYBLOB_PUBLIC_KEY, (UINT32)offset, pub_blob); 533 if (result != TSS_SUCCESS) { 534 stlogit("Tspi_SetAttribData failed: rc=0x%0x - %s\n", 535 result, Trspi_Error_String(result)); 536 return (result); 537 } 538 539 return (result); 540 } 541 542 /* 543 * Get details about the TPM to put into the token_info structure. 544 */ 545 CK_RV 546 token_get_tpm_info(TSS_HCONTEXT hContext, TOKEN_DATA *td) 547 { 548 TSS_RESULT result; 549 TPM_CAPABILITY_AREA capArea = TSS_TPMCAP_VERSION_VAL; 550 UINT32 datalen; 551 BYTE *data; 552 TSS_HTPM hTPM; 553 554 if ((result = Tspi_Context_GetTpmObject(hContext, &hTPM))) { 555 stlogit("Tspi_Context_GetTpmObject: 0x%0x - %s", 556 result, Trspi_Error_String(result)); 557 return (CKR_FUNCTION_FAILED); 558 } 559 if ((result = Tspi_TPM_GetCapability(hTPM, 560 capArea, 0, NULL, &datalen, &data)) != 0 || datalen == 0 || 561 data == NULL) { 562 stlogit("Tspi_Context_GetCapability: 0x%0x - %s", 563 result, Trspi_Error_String(result)); 564 return (CKR_FUNCTION_FAILED); 565 } 566 if (datalen > sizeof (tpmvinfo)) { 567 Tspi_Context_FreeMemory(hContext, data); 568 return (CKR_FUNCTION_FAILED); 569 } 570 571 (void) memcpy(&tpmvinfo, (void *)data, datalen); 572 573 bzero(td->token_info.manufacturerID, 574 sizeof (td->token_info.manufacturerID)); 575 576 (void) memset(td->token_info.manufacturerID, ' ', 577 sizeof (td->token_info.manufacturerID) - 1); 578 579 (void) memcpy(td->token_info.manufacturerID, 580 tpmvinfo.tpmVendorID, sizeof (tpmvinfo.tpmVendorID)); 581 582 (void) memset(td->token_info.label, ' ', 583 sizeof (td->token_info.label) - 1); 584 585 (void) memcpy(td->token_info.label, "TPM", 3); 586 587 td->token_info.hardwareVersion.major = tpmvinfo.version.major; 588 td->token_info.hardwareVersion.minor = tpmvinfo.version.minor; 589 td->token_info.firmwareVersion.major = tpmvinfo.version.revMajor; 590 td->token_info.firmwareVersion.minor = tpmvinfo.version.revMinor; 591 592 Tspi_Context_FreeMemory(hContext, data); 593 return (CKR_OK); 594 } 595 596 /*ARGSUSED*/ 597 CK_RV 598 token_specific_session(CK_SLOT_ID slotid) 599 { 600 return (CKR_OK); 601 } 602 603 CK_RV 604 token_rng(TSS_HCONTEXT hContext, CK_BYTE *output, CK_ULONG bytes) 605 { 606 TSS_RESULT rc; 607 TSS_HTPM hTPM; 608 BYTE *random_bytes = NULL; 609 610 if ((rc = Tspi_Context_GetTpmObject(hContext, &hTPM))) { 611 stlogit("Tspi_Context_GetTpmObject: 0x%0x - %s", 612 rc, Trspi_Error_String(rc)); 613 return (CKR_FUNCTION_FAILED); 614 } 615 616 if ((rc = Tspi_TPM_GetRandom(hTPM, bytes, &random_bytes))) { 617 stlogit("Tspi_TPM_GetRandom: 0x%0x - %s", 618 rc, Trspi_Error_String(rc)); 619 return (CKR_FUNCTION_FAILED); 620 } 621 622 (void) memcpy(output, random_bytes, bytes); 623 Tspi_Context_FreeMemory(hContext, random_bytes); 624 625 return (CKR_OK); 626 } 627 628 TSS_RESULT 629 open_tss_context(TSS_HCONTEXT *pContext) 630 { 631 TSS_RESULT result; 632 633 if ((result = Tspi_Context_Create(pContext))) { 634 stlogit("Tspi_Context_Create: 0x%0x - %s", 635 result, Trspi_Error_String(result)); 636 return (CKR_FUNCTION_FAILED); 637 } 638 639 if ((result = Tspi_Context_Connect(*pContext, NULL))) { 640 stlogit("Tspi_Context_Connect: 0x%0x - %s", 641 result, Trspi_Error_String(result)); 642 Tspi_Context_Close(*pContext); 643 *pContext = 0; 644 return (CKR_FUNCTION_FAILED); 645 } 646 return (result); 647 } 648 649 /*ARGSUSED*/ 650 static CK_RV 651 token_specific_init(char *Correlator, CK_SLOT_ID SlotNumber, 652 TSS_HCONTEXT *hContext) 653 { 654 TSS_RESULT result; 655 656 result = open_tss_context(hContext); 657 if (result) 658 return (CKR_FUNCTION_FAILED); 659 660 if ((result = Tspi_Context_GetDefaultPolicy(*hContext, 661 &hDefaultPolicy))) { 662 stlogit("Tspi_Context_GetDefaultPolicy: 0x%0x - %s", 663 result, Trspi_Error_String(result)); 664 return (CKR_FUNCTION_FAILED); 665 } 666 667 local_uuid_clear(&publicRootKeyUUID); 668 local_uuid_clear(&privateRootKeyUUID); 669 local_uuid_clear(&publicLeafKeyUUID); 670 local_uuid_clear(&privateLeafKeyUUID); 671 672 result = token_get_tpm_info(*hContext, nv_token_data); 673 return (result); 674 } 675 676 /* 677 * Given a modulus and prime from an RSA key, create a TSS_HKEY object by 678 * wrapping the RSA key with a key from the TPM (SRK or other previously stored 679 * key). 680 */ 681 static CK_RV 682 token_wrap_sw_key( 683 TSS_HCONTEXT hContext, 684 int size_n, 685 unsigned char *n, 686 int size_p, 687 unsigned char *p, 688 TSS_HKEY hParentKey, 689 TSS_FLAG initFlags, 690 TSS_HKEY *phKey) 691 { 692 TSS_RESULT result; 693 UINT32 key_size; 694 695 key_size = util_get_keysize_flag(size_n * 8); 696 if (initFlags == 0) { 697 return (CKR_FUNCTION_FAILED); 698 } 699 700 /* create the TSS key object */ 701 result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY, 702 TSS_KEY_MIGRATABLE | initFlags | key_size, phKey); 703 if (result != TSS_SUCCESS) { 704 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 705 result, Trspi_Error_String(result)); 706 return (CKR_FUNCTION_FAILED); 707 } 708 709 result = set_public_modulus(hContext, *phKey, size_n, n); 710 if (result != TSS_SUCCESS) { 711 Tspi_Context_CloseObject(hContext, *phKey); 712 *phKey = NULL_HKEY; 713 return (CKR_FUNCTION_FAILED); 714 } 715 716 /* set the private key data in the TSS object */ 717 result = Tspi_SetAttribData(*phKey, TSS_TSPATTRIB_KEY_BLOB, 718 TSS_TSPATTRIB_KEYBLOB_PRIVATE_KEY, size_p, p); 719 if (result != TSS_SUCCESS) { 720 stlogit("Tspi_SetAttribData: 0x%x - %s", 721 result, Trspi_Error_String(result)); 722 Tspi_Context_CloseObject(hContext, *phKey); 723 *phKey = NULL_HKEY; 724 return (CKR_FUNCTION_FAILED); 725 } 726 727 result = tss_assign_secret_key_policy(hContext, TSS_POLICY_MIGRATION, 728 *phKey, NULL); 729 730 if (TPMTOK_TSS_KEY_TYPE(initFlags) == TSS_KEY_TYPE_LEGACY) { 731 if ((result = Tspi_SetAttribUint32(*phKey, 732 TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_ENCSCHEME, 733 TSS_ES_RSAESPKCSV15))) { 734 stlogit("Tspi_SetAttribUint32: 0x%0x - %s\n", 735 result, Trspi_Error_String(result)); 736 Tspi_Context_CloseObject(hContext, *phKey); 737 return (CKR_FUNCTION_FAILED); 738 } 739 740 if ((result = Tspi_SetAttribUint32(*phKey, 741 TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_SIGSCHEME, 742 TSS_SS_RSASSAPKCS1V15_DER))) { 743 stlogit("Tspi_SetAttribUint32: 0x%0x - %s\n", 744 result, Trspi_Error_String(result)); 745 Tspi_Context_CloseObject(hContext, *phKey); 746 return (CKR_FUNCTION_FAILED); 747 } 748 } 749 750 result = Tspi_Key_WrapKey(*phKey, hParentKey, NULL_HPCRS); 751 if (result != TSS_SUCCESS) { 752 stlogit("Tspi_Key_WrapKey: 0x%0x - %s", 753 result, Trspi_Error_String(result)); 754 Tspi_Context_CloseObject(hContext, *phKey); 755 *phKey = NULL_HKEY; 756 return (CKR_FUNCTION_FAILED); 757 } 758 759 return (CKR_OK); 760 } 761 762 /* 763 * Create a TPM key blob for an imported key. This function is only called when 764 * a key is in active use, so any failure should trickle through. 765 */ 766 static CK_RV 767 token_wrap_key_object(TSS_HCONTEXT hContext, 768 CK_OBJECT_HANDLE ckObject, 769 TSS_HKEY hParentKey, TSS_HKEY *phKey) 770 { 771 CK_RV rc = CKR_OK; 772 CK_ATTRIBUTE *attr = NULL, *new_attr, *prime_attr; 773 CK_ULONG class, key_type; 774 OBJECT *obj; 775 776 TSS_RESULT result; 777 TSS_FLAG initFlags = 0; 778 BYTE *rgbBlob; 779 UINT32 ulBlobLen; 780 781 if ((rc = object_mgr_find_in_map1(hContext, ckObject, &obj))) { 782 return (rc); 783 } 784 785 /* if the object isn't a key, fail */ 786 if (template_attribute_find(obj->template, CKA_KEY_TYPE, 787 &attr) == FALSE) { 788 return (CKR_TEMPLATE_INCOMPLETE); 789 } 790 791 key_type = *((CK_ULONG *)attr->pValue); 792 793 if (key_type != CKK_RSA) { 794 return (CKR_TEMPLATE_INCONSISTENT); 795 } 796 797 if (template_attribute_find(obj->template, CKA_CLASS, 798 &attr) == FALSE) { 799 return (CKR_TEMPLATE_INCOMPLETE); 800 } 801 802 class = *((CK_ULONG *)attr->pValue); 803 804 if (class == CKO_PRIVATE_KEY) { 805 /* 806 * In order to create a full TSS key blob using a PKCS#11 807 * private key object, we need one of the two primes, the 808 * modulus and the private exponent and we need the public 809 * exponent to be correct. 810 */ 811 812 /* 813 * Check the least likely attribute to exist first, the 814 * primes. 815 */ 816 if (template_attribute_find(obj->template, CKA_PRIME_1, 817 &prime_attr) == FALSE) { 818 if (template_attribute_find(obj->template, 819 CKA_PRIME_2, &prime_attr) == FALSE) { 820 return (CKR_TEMPLATE_INCOMPLETE); 821 } 822 } 823 824 /* Make sure the public exponent is usable */ 825 if ((rc = util_check_public_exponent(obj->template))) { 826 return (CKR_TEMPLATE_INCONSISTENT); 827 } 828 829 /* get the modulus */ 830 if (template_attribute_find(obj->template, CKA_MODULUS, 831 &attr) == FALSE) { 832 return (CKR_TEMPLATE_INCOMPLETE); 833 } 834 835 /* make sure the key size is usable */ 836 initFlags = util_get_keysize_flag(attr->ulValueLen * 8); 837 if (initFlags == 0) { 838 return (CKR_TEMPLATE_INCONSISTENT); 839 } 840 841 /* generate the software based key */ 842 if ((rc = token_wrap_sw_key(hContext, 843 (int)attr->ulValueLen, attr->pValue, 844 (int)prime_attr->ulValueLen, prime_attr->pValue, 845 hParentKey, TSS_KEY_TYPE_LEGACY | TSS_KEY_NO_AUTHORIZATION, 846 phKey))) { 847 return (rc); 848 } 849 } else if (class == CKO_PUBLIC_KEY) { 850 /* Make sure the public exponent is usable */ 851 if ((util_check_public_exponent(obj->template))) { 852 return (CKR_TEMPLATE_INCONSISTENT); 853 } 854 855 /* grab the modulus to put into the TSS key object */ 856 if (template_attribute_find(obj->template, 857 CKA_MODULUS, &attr) == FALSE) { 858 return (CKR_TEMPLATE_INCONSISTENT); 859 } 860 861 /* make sure the key size is usable */ 862 initFlags = util_get_keysize_flag(attr->ulValueLen * 8); 863 if (initFlags == 0) { 864 return (CKR_TEMPLATE_INCONSISTENT); 865 } 866 867 initFlags |= TSS_KEY_MIGRATABLE | TSS_KEY_NO_AUTHORIZATION | 868 TSS_KEY_TYPE_LEGACY; 869 870 if ((result = Tspi_Context_CreateObject(hContext, 871 TSS_OBJECT_TYPE_RSAKEY, initFlags, phKey))) { 872 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 873 result, Trspi_Error_String(result)); 874 return (result); 875 } 876 877 if ((result = set_public_modulus(hContext, *phKey, 878 attr->ulValueLen, attr->pValue))) { 879 Tspi_Context_CloseObject(hContext, *phKey); 880 *phKey = NULL_HKEY; 881 return (CKR_FUNCTION_FAILED); 882 } 883 result = tss_assign_secret_key_policy(hContext, 884 TSS_POLICY_MIGRATION, *phKey, NULL); 885 if (result) { 886 Tspi_Context_CloseObject(hContext, *phKey); 887 *phKey = NULL_HKEY; 888 return (CKR_FUNCTION_FAILED); 889 } 890 891 result = set_legacy_key_params(*phKey); 892 if (result) { 893 Tspi_Context_CloseObject(hContext, *phKey); 894 *phKey = NULL_HKEY; 895 return (CKR_FUNCTION_FAILED); 896 } 897 } else { 898 return (CKR_FUNCTION_FAILED); 899 } 900 901 /* grab the entire key blob to put into the PKCS#11 object */ 902 if ((result = Tspi_GetAttribData(*phKey, TSS_TSPATTRIB_KEY_BLOB, 903 TSS_TSPATTRIB_KEYBLOB_BLOB, &ulBlobLen, &rgbBlob))) { 904 stlogit("Tspi_GetAttribData: 0x%0x - %s", 905 result, Trspi_Error_String(result)); 906 return (CKR_FUNCTION_FAILED); 907 } 908 909 /* insert the key blob into the object */ 910 if ((rc = build_attribute(CKA_IBM_OPAQUE, rgbBlob, ulBlobLen, 911 &new_attr))) { 912 Tspi_Context_FreeMemory(hContext, rgbBlob); 913 return (rc); 914 } 915 (void) template_update_attribute(obj->template, new_attr); 916 Tspi_Context_FreeMemory(hContext, rgbBlob); 917 918 /* 919 * If this is a token object, save it with the new attribute 920 * so that we don't have to go down this path again. 921 */ 922 if (!object_is_session_object(obj)) { 923 rc = save_token_object(hContext, obj); 924 } 925 926 return (rc); 927 } 928 929 static TSS_RESULT 930 tss_assign_secret_key_policy(TSS_HCONTEXT hContext, TSS_FLAG policyType, 931 TSS_HKEY hKey, CK_CHAR *passHash) 932 { 933 TSS_RESULT result; 934 TSS_HPOLICY hPolicy; 935 936 if ((result = Tspi_Context_CreateObject(hContext, 937 TSS_OBJECT_TYPE_POLICY, policyType, &hPolicy))) { 938 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 939 result, Trspi_Error_String(result)); 940 return (result); 941 } 942 if ((result = Tspi_Policy_AssignToObject(hPolicy, hKey))) { 943 stlogit("Tspi_Policy_AssignToObject: 0x%0x - %s", 944 result, Trspi_Error_String(result)); 945 goto done; 946 } 947 if (passHash == NULL) { 948 result = Tspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_NONE, 949 0, NULL); 950 } else { 951 result = Tspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_SHA1, 952 SHA1_DIGEST_LENGTH, passHash); 953 } 954 if (result != TSS_SUCCESS) { 955 stlogit("Tspi_Policy_SetSecret: 0x%0x - %s", 956 result, Trspi_Error_String(result)); 957 goto done; 958 } 959 done: 960 if (result != TSS_SUCCESS) 961 Tspi_Context_CloseObject(hContext, hPolicy); 962 return (result); 963 } 964 965 /* 966 * Take a key from the TSS store (on-disk) and load it into the TPM, wrapped 967 * by an already TPM-resident key and protected with a PIN (optional). 968 */ 969 static CK_RV 970 token_load_key( 971 TSS_HCONTEXT hContext, 972 CK_OBJECT_HANDLE ckKey, 973 TSS_HKEY hParentKey, 974 CK_CHAR_PTR passHash, 975 TSS_HKEY *phKey) 976 { 977 TSS_RESULT result; 978 CK_RV rc; 979 980 /* 981 * The key blob wasn't found, load the parts of the key 982 * from the object DB and create a new key object that 983 * gets loaded into the TPM, wrapped with the parent key. 984 */ 985 if ((rc = token_wrap_key_object(hContext, ckKey, 986 hParentKey, phKey))) { 987 return (rc); 988 } 989 990 /* 991 * Assign the PIN hash (optional) to the newly loaded key object, 992 * if this PIN is incorrect, the TPM will not be able to decrypt 993 * the private key and use it. 994 */ 995 result = tss_assign_secret_key_policy(hContext, TSS_POLICY_USAGE, 996 *phKey, passHash); 997 998 return (result); 999 } 1000 1001 /* 1002 * Load the SRK into the TPM by referencing its well-known UUID and using the 1003 * default SRK PIN (20 bytes of 0x00). 1004 * 1005 * NOTE - if the SRK PIN is changed by an administrative tool, this code will 1006 * fail because it assumes that the well-known PIN is still being used. 1007 */ 1008 static TSS_RESULT 1009 token_load_srk(TSS_HCONTEXT hContext, TSS_HKEY *hSRK) 1010 { 1011 TSS_HPOLICY hPolicy; 1012 TSS_RESULT result; 1013 TSS_UUID SRK_UUID = TSS_UUID_SRK; 1014 BYTE wellKnown[] = TSS_WELL_KNOWN_SECRET; 1015 TSS_HTPM hTPM; 1016 1017 if ((result = Tspi_Context_GetTpmObject(hContext, &hTPM))) { 1018 stlogit("Tspi_Context_GetTpmObject: 0x%0x - %s", 1019 result, Trspi_Error_String(result)); 1020 return (CKR_FUNCTION_FAILED); 1021 } 1022 1023 /* load the SRK */ 1024 if ((result = Tspi_Context_LoadKeyByUUID(hContext, 1025 TSS_PS_TYPE_SYSTEM, SRK_UUID, hSRK))) { 1026 stlogit("Tspi_Context_LoadKeyByUUID: 0x%0x - %s", 1027 result, Trspi_Error_String(result)); 1028 goto done; 1029 } 1030 if ((result = Tspi_GetPolicyObject(*hSRK, TSS_POLICY_USAGE, 1031 &hPolicy))) { 1032 stlogit("Tspi_GetPolicyObject: 0x%0x - %s", 1033 result, Trspi_Error_String(result)); 1034 goto done; 1035 } 1036 if ((result = Tspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_SHA1, 1037 sizeof (wellKnown), wellKnown))) { 1038 stlogit("Tspi_Policy_SetSecret: 0x%0x - %s", 1039 result, Trspi_Error_String(result)); 1040 goto done; 1041 } 1042 1043 done: 1044 return (result); 1045 } 1046 1047 static TSS_RESULT 1048 tss_find_and_load_key(TSS_HCONTEXT hContext, 1049 char *keyid, TSS_UUID *uuid, TSS_HKEY hParent, 1050 BYTE *hash, TSS_HKEY *hKey) 1051 { 1052 TSS_RESULT result; 1053 1054 if (local_uuid_is_null(uuid) && 1055 find_uuid(keyid, uuid)) { 1056 /* The UUID was not created or saved yet */ 1057 return (1); 1058 } 1059 result = Tspi_Context_GetKeyByUUID(hContext, 1060 TSS_PS_TYPE_USER, *uuid, hKey); 1061 if (result) { 1062 stlogit("Tspi_Context_GetKeyByUUID: 0x%0x - %s", 1063 result, Trspi_Error_String(result)); 1064 return (result); 1065 } 1066 1067 if (hash != NULL) { 1068 result = tss_assign_secret_key_policy(hContext, 1069 TSS_POLICY_USAGE, *hKey, (CK_BYTE *)hash); 1070 if (result) 1071 return (result); 1072 } 1073 1074 result = Tspi_Key_LoadKey(*hKey, hParent); 1075 if (result) 1076 stlogit("Tspi_Key_LoadKey: 0x%0x - %s", 1077 result, Trspi_Error_String(result)); 1078 1079 return (result); 1080 } 1081 1082 static TSS_RESULT 1083 token_load_public_root_key(TSS_HCONTEXT hContext) 1084 { 1085 TSS_RESULT result; 1086 TSS_HKEY hSRK; 1087 1088 if (hPublicRootKey != NULL_HKEY) 1089 return (TSS_SUCCESS); 1090 1091 if ((result = token_load_srk(hContext, &hSRK))) { 1092 return (result); 1093 } 1094 1095 result = tss_find_and_load_key(hContext, 1096 TPMTOK_PUBLIC_ROOT_KEY_ID, 1097 &publicRootKeyUUID, hSRK, NULL, &hPublicRootKey); 1098 if (result) 1099 return (result); 1100 1101 return (result); 1102 } 1103 1104 static TSS_RESULT 1105 set_legacy_key_params(TSS_HKEY hKey) 1106 { 1107 TSS_RESULT result; 1108 1109 if ((result = Tspi_SetAttribUint32(hKey, 1110 TSS_TSPATTRIB_KEY_INFO, 1111 TSS_TSPATTRIB_KEYINFO_ENCSCHEME, 1112 TSS_ES_RSAESPKCSV15))) { 1113 stlogit("Tspi_SetAttribUint32: 0x%0x - %s", 1114 result, Trspi_Error_String(result)); 1115 return (result); 1116 } 1117 1118 if ((result = Tspi_SetAttribUint32(hKey, 1119 TSS_TSPATTRIB_KEY_INFO, 1120 TSS_TSPATTRIB_KEYINFO_SIGSCHEME, 1121 TSS_SS_RSASSAPKCS1V15_DER))) { 1122 stlogit("Tspi_SetAttribUint32: 0x%0x - %s", 1123 result, Trspi_Error_String(result)); 1124 return (result); 1125 } 1126 1127 return (result); 1128 } 1129 1130 static TSS_RESULT 1131 tss_generate_key(TSS_HCONTEXT hContext, TSS_FLAG initFlags, BYTE *passHash, 1132 TSS_HKEY hParentKey, TSS_HKEY *phKey) 1133 { 1134 TSS_RESULT result; 1135 TSS_HPOLICY hMigPolicy; 1136 1137 if ((result = Tspi_Context_CreateObject(hContext, 1138 TSS_OBJECT_TYPE_RSAKEY, initFlags, phKey))) { 1139 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 1140 result, Trspi_Error_String(result)); 1141 return (result); 1142 } 1143 result = tss_assign_secret_key_policy(hContext, TSS_POLICY_USAGE, 1144 *phKey, passHash); 1145 1146 if (result) { 1147 Tspi_Context_CloseObject(hContext, *phKey); 1148 return (result); 1149 } 1150 1151 if (TPMTOK_TSS_KEY_MIG_TYPE(initFlags) == TSS_KEY_MIGRATABLE) { 1152 if ((result = Tspi_Context_CreateObject(hContext, 1153 TSS_OBJECT_TYPE_POLICY, TSS_POLICY_MIGRATION, 1154 &hMigPolicy))) { 1155 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 1156 result, Trspi_Error_String(result)); 1157 Tspi_Context_CloseObject(hContext, *phKey); 1158 return (result); 1159 } 1160 1161 if (passHash == NULL) { 1162 result = Tspi_Policy_SetSecret(hMigPolicy, 1163 TSS_SECRET_MODE_NONE, 0, NULL); 1164 } else { 1165 result = Tspi_Policy_SetSecret(hMigPolicy, 1166 TSS_SECRET_MODE_SHA1, 20, passHash); 1167 } 1168 1169 if (result != TSS_SUCCESS) { 1170 stlogit("Tspi_Policy_SetSecret: 0x%0x - %s", 1171 result, Trspi_Error_String(result)); 1172 Tspi_Context_CloseObject(hContext, *phKey); 1173 Tspi_Context_CloseObject(hContext, hMigPolicy); 1174 return (result); 1175 } 1176 1177 if ((result = Tspi_Policy_AssignToObject(hMigPolicy, *phKey))) { 1178 stlogit("Tspi_Policy_AssignToObject: 0x%0x - %s", 1179 result, Trspi_Error_String(result)); 1180 Tspi_Context_CloseObject(hContext, *phKey); 1181 Tspi_Context_CloseObject(hContext, hMigPolicy); 1182 return (result); 1183 } 1184 } 1185 1186 if (TPMTOK_TSS_KEY_TYPE(initFlags) == TSS_KEY_TYPE_LEGACY) { 1187 result = set_legacy_key_params(*phKey); 1188 if (result) { 1189 Tspi_Context_CloseObject(hContext, *phKey); 1190 Tspi_Context_CloseObject(hContext, hMigPolicy); 1191 return (result); 1192 } 1193 } 1194 1195 if ((result = Tspi_Key_CreateKey(*phKey, hParentKey, 0))) { 1196 stlogit("Tspi_Key_CreateKey: 0x%0x - %s", 1197 result, Trspi_Error_String(result)); 1198 Tspi_Context_CloseObject(hContext, *phKey); 1199 Tspi_Context_CloseObject(hContext, hMigPolicy); 1200 } 1201 1202 return (result); 1203 } 1204 1205 static TSS_RESULT 1206 tss_change_auth( 1207 TSS_HCONTEXT hContext, 1208 TSS_HKEY hObjectToChange, TSS_HKEY hParentObject, 1209 TSS_UUID objUUID, TSS_UUID parentUUID, 1210 CK_CHAR *passHash) 1211 { 1212 TSS_RESULT result; 1213 TSS_HPOLICY hPolicy; 1214 TSS_HKEY oldkey; 1215 1216 if ((result = Tspi_Context_CreateObject(hContext, 1217 TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, &hPolicy))) { 1218 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 1219 result, Trspi_Error_String(result)); 1220 return (result); 1221 } 1222 1223 if ((result = Tspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_SHA1, 1224 SHA1_DIGEST_LENGTH, passHash))) { 1225 stlogit("Tspi_Policy_SetSecret: 0x%0x - %s", 1226 result, Trspi_Error_String(result)); 1227 return (result); 1228 } 1229 1230 if ((result = Tspi_ChangeAuth(hObjectToChange, hParentObject, 1231 hPolicy))) { 1232 stlogit("Tspi_ChangeAuth: 0x%0x - %s", 1233 result, Trspi_Error_String(result)); 1234 } 1235 /* 1236 * Update the PS key by unregistering the key UUID and then 1237 * re-registering with the same UUID. This forces the updated 1238 * auth data associated with the key to be stored in PS so 1239 * the new PIN can be used next time. 1240 */ 1241 if ((result = Tspi_Context_UnregisterKey(hContext, 1242 TSS_PS_TYPE_USER, objUUID, &oldkey))) 1243 stlogit("Tspi_Context_UnregisterKey: 0x%0x - %s", 1244 result, Trspi_Error_String(result)); 1245 1246 if ((result = Tspi_Context_RegisterKey(hContext, hObjectToChange, 1247 TSS_PS_TYPE_USER, objUUID, TSS_PS_TYPE_USER, parentUUID))) 1248 stlogit("Tspi_Context_RegisterKey: 0x%0x - %s", 1249 result, Trspi_Error_String(result)); 1250 1251 return (result); 1252 } 1253 1254 static CK_RV 1255 token_generate_leaf_key(TSS_HCONTEXT hContext, 1256 int key_type, CK_CHAR_PTR passHash, TSS_HKEY *phKey) 1257 { 1258 CK_RV rc = CKR_FUNCTION_FAILED; 1259 TSS_RESULT result; 1260 TSS_HKEY hParentKey; 1261 TSS_UUID newuuid, parentUUID; 1262 char *keyid; 1263 TSS_FLAG initFlags = TSS_KEY_MIGRATABLE | 1264 TSS_KEY_TYPE_BIND | TSS_KEY_SIZE_2048 | TSS_KEY_AUTHORIZATION; 1265 1266 switch (key_type) { 1267 case TPMTOK_PUBLIC_LEAF_KEY: 1268 hParentKey = hPublicRootKey; 1269 keyid = TPMTOK_PUBLIC_LEAF_KEY_ID; 1270 local_uuid_copy(&parentUUID, &publicRootKeyUUID); 1271 break; 1272 case TPMTOK_PRIVATE_LEAF_KEY: 1273 hParentKey = hPrivateRootKey; 1274 keyid = TPMTOK_PRIVATE_LEAF_KEY_ID; 1275 local_uuid_copy(&parentUUID, &privateRootKeyUUID); 1276 break; 1277 default: 1278 stlogit("Unknown key type 0x%0x", key_type); 1279 goto done; 1280 } 1281 1282 if (result = tss_generate_key(hContext, initFlags, passHash, 1283 hParentKey, phKey)) { 1284 return (rc); 1285 } 1286 1287 /* 1288 * - generate newUUID 1289 * - Tspi_Context_RegisterKey(hContext, hPrivateRootKey, 1290 * USER, newUUID, USER, parentUUID); 1291 * - store newUUID 1292 */ 1293 (void) local_uuid_generate(&newuuid); 1294 1295 result = Tspi_Context_RegisterKey(hContext, *phKey, 1296 TSS_PS_TYPE_USER, newuuid, 1297 TSS_PS_TYPE_USER, parentUUID); 1298 if (result == TSS_SUCCESS) { 1299 int ret; 1300 /* 1301 * Add the UUID to the token UUID index. 1302 */ 1303 ret = add_uuid(keyid, &newuuid); 1304 1305 if (ret) 1306 result = Tspi_Context_UnregisterKey(hContext, 1307 TSS_PS_TYPE_USER, newuuid, phKey); 1308 else 1309 rc = CKR_OK; 1310 } 1311 1312 done: 1313 return (rc); 1314 } 1315 1316 /* 1317 * PINs are verified by attempting to bind/unbind random data using a 1318 * TPM resident key that has the PIN being tested assigned as its "secret". 1319 * If the PIN is incorrect, the unbind operation will fail. 1320 */ 1321 static CK_RV 1322 token_verify_pin(TSS_HCONTEXT hContext, TSS_HKEY hKey) 1323 { 1324 TSS_HENCDATA hEncData; 1325 UINT32 ulUnboundDataLen; 1326 BYTE *rgbUnboundData = NULL; 1327 BYTE rgbData[16]; 1328 TSS_RESULT result; 1329 CK_RV rc = CKR_FUNCTION_FAILED; 1330 1331 if ((result = Tspi_Context_CreateObject(hContext, 1332 TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND, &hEncData))) { 1333 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 1334 result, Trspi_Error_String(result)); 1335 goto done; 1336 } 1337 1338 /* Use some random data */ 1339 rc = token_rng(hContext, rgbData, sizeof (rgbData)); 1340 if (rc) 1341 goto done; 1342 1343 if ((result = Tspi_Data_Bind(hEncData, hKey, 1344 sizeof (rgbData), rgbData))) { 1345 stlogit("Tspi_Data_Bind: 0x%0x - %s", 1346 result, Trspi_Error_String(result)); 1347 goto done; 1348 } 1349 1350 /* unbind the junk data to test the key's auth data */ 1351 result = Tspi_Data_Unbind(hEncData, hKey, &ulUnboundDataLen, 1352 &rgbUnboundData); 1353 if (result == TPM_E_AUTHFAIL) { 1354 rc = CKR_PIN_INCORRECT; 1355 stlogit("Tspi_Data_Unbind: 0x%0x - %s", 1356 result, Trspi_Error_String(result)); 1357 goto done; 1358 } else if (result != TSS_SUCCESS) { 1359 stlogit("Tspi_Data_Unbind: 0x%0x - %s", 1360 result, Trspi_Error_String(result)); 1361 rc = CKR_FUNCTION_FAILED; 1362 goto done; 1363 } 1364 1365 if (memcmp(rgbUnboundData, rgbData, ulUnboundDataLen)) 1366 rc = CKR_PIN_INCORRECT; 1367 else 1368 rc = CKR_OK; 1369 1370 done: 1371 if (rgbUnboundData != NULL) 1372 Tspi_Context_FreeMemory(hContext, rgbUnboundData); 1373 Tspi_Context_CloseObject(hContext, hEncData); 1374 return (rc); 1375 } 1376 1377 static CK_RV 1378 token_create_private_tree(TSS_HCONTEXT hContext, CK_BYTE *pinHash) 1379 { 1380 CK_RV rc; 1381 TSS_RESULT result; 1382 int ret; 1383 TSS_FLAG initFlags = TSS_KEY_SIZE_2048 | 1384 TSS_KEY_NO_AUTHORIZATION | TSS_KEY_TYPE_STORAGE; 1385 TSS_UUID SRK_UUID = TSS_UUID_SRK; 1386 TSS_HKEY hSRK; 1387 1388 if (token_load_srk(hContext, &hSRK)) 1389 return (CKR_FUNCTION_FAILED); 1390 1391 /* 1392 * - create UUID privateRootKeyUUID 1393 * - Tspi_Context_RegisterKey(hContext, hPrivateRootKey, 1394 * USER, privateRootKeyUUID, system, UUID_SRK); 1395 * - store privateRootKeyUUID in users private token space. 1396 */ 1397 if ((result = tss_generate_key(hContext, initFlags, NULL, hSRK, 1398 &hPrivateRootKey))) { 1399 return (result); 1400 } 1401 if (local_uuid_is_null(&privateRootKeyUUID)) 1402 local_uuid_generate(&privateRootKeyUUID); 1403 1404 result = Tspi_Context_RegisterKey(hContext, hPrivateRootKey, 1405 TSS_PS_TYPE_USER, privateRootKeyUUID, 1406 TSS_PS_TYPE_SYSTEM, SRK_UUID); 1407 1408 if (result) { 1409 local_uuid_clear(&privateRootKeyUUID); 1410 return (result); 1411 } 1412 1413 ret = add_uuid(TPMTOK_PRIVATE_ROOT_KEY_ID, &privateRootKeyUUID); 1414 if (ret) { 1415 result = Tspi_Context_UnregisterKey(hContext, 1416 TSS_PS_TYPE_USER, privateRootKeyUUID, 1417 &hPrivateRootKey); 1418 return (CKR_FUNCTION_FAILED); 1419 } 1420 1421 if ((result = Tspi_Key_LoadKey(hPrivateRootKey, hSRK))) { 1422 stlogit("Tspi_Key_LoadKey: 0x%0x - %s", 1423 result, Trspi_Error_String(result)); 1424 Tspi_Context_CloseObject(hContext, hPrivateRootKey); 1425 1426 (void) remove_uuid(TPMTOK_PRIVATE_ROOT_KEY_ID); 1427 local_uuid_clear(&privateRootKeyUUID); 1428 1429 hPrivateRootKey = NULL_HKEY; 1430 return (CKR_FUNCTION_FAILED); 1431 } 1432 1433 1434 /* generate the private leaf key */ 1435 if ((rc = token_generate_leaf_key(hContext, 1436 TPMTOK_PRIVATE_LEAF_KEY, 1437 pinHash, &hPrivateLeafKey))) { 1438 return (rc); 1439 } 1440 1441 if ((result = Tspi_Key_LoadKey(hPrivateLeafKey, hPrivateRootKey))) { 1442 stlogit("Tspi_Key_LoadKey: 0x%0x - %s", 1443 result, Trspi_Error_String(result)); 1444 1445 (void) Tspi_Context_UnregisterKey(hContext, 1446 TSS_PS_TYPE_USER, privateLeafKeyUUID, 1447 &hPrivateLeafKey); 1448 (void) remove_uuid(TPMTOK_PRIVATE_LEAF_KEY_ID); 1449 local_uuid_clear(&privateLeafKeyUUID); 1450 1451 (void) Tspi_Context_UnregisterKey(hContext, 1452 TSS_PS_TYPE_USER, privateRootKeyUUID, 1453 &hPrivateRootKey); 1454 (void) remove_uuid(TPMTOK_PRIVATE_ROOT_KEY_ID); 1455 local_uuid_clear(&privateRootKeyUUID); 1456 1457 Tspi_Context_CloseObject(hContext, hPrivateRootKey); 1458 hPrivateRootKey = NULL_HKEY; 1459 1460 Tspi_Context_CloseObject(hContext, hPrivateLeafKey); 1461 hPrivateRootKey = NULL_HKEY; 1462 1463 return (CKR_FUNCTION_FAILED); 1464 } 1465 return (rc); 1466 } 1467 1468 static CK_RV 1469 token_create_public_tree(TSS_HCONTEXT hContext, CK_BYTE *pinHash) 1470 { 1471 CK_RV rc; 1472 TSS_RESULT result; 1473 int ret; 1474 TSS_FLAG initFlags = TSS_KEY_SIZE_2048 | 1475 TSS_KEY_NO_AUTHORIZATION | TSS_KEY_TYPE_STORAGE; 1476 TSS_UUID srk_uuid = TSS_UUID_SRK; 1477 TSS_HKEY hSRK; 1478 1479 if (token_load_srk(hContext, &hSRK)) 1480 return (CKR_FUNCTION_FAILED); 1481 1482 /* 1483 * - create publicRootKeyUUID 1484 * - Tspi_Context_RegisterKey(hContext, hPublicRootKey, 1485 * USER, publicRootKeyUUID, system, UUID_SRK); 1486 * - store publicRootKeyUUID in users private token space. 1487 */ 1488 if ((result = tss_generate_key(hContext, initFlags, NULL, hSRK, 1489 &hPublicRootKey))) { 1490 return (CKR_FUNCTION_FAILED); 1491 } 1492 if (local_uuid_is_null(&publicRootKeyUUID)) 1493 local_uuid_generate(&publicRootKeyUUID); 1494 1495 result = Tspi_Context_RegisterKey(hContext, hPublicRootKey, 1496 TSS_PS_TYPE_USER, publicRootKeyUUID, 1497 TSS_PS_TYPE_SYSTEM, srk_uuid); 1498 1499 if (result) { 1500 local_uuid_clear(&publicRootKeyUUID); 1501 return (CKR_FUNCTION_FAILED); 1502 } 1503 1504 ret = add_uuid(TPMTOK_PUBLIC_ROOT_KEY_ID, &publicRootKeyUUID); 1505 if (ret) { 1506 result = Tspi_Context_UnregisterKey(hContext, 1507 TSS_PS_TYPE_USER, publicRootKeyUUID, 1508 &hPublicRootKey); 1509 /* does result matter here? */ 1510 return (CKR_FUNCTION_FAILED); 1511 } 1512 1513 /* Load the newly created publicRootKey into the TPM using the SRK */ 1514 if ((result = Tspi_Key_LoadKey(hPublicRootKey, hSRK))) { 1515 stlogit("Tspi_Key_LoadKey: 0x%x - %s", result, 1516 Trspi_Error_String(result)); 1517 Tspi_Context_CloseObject(hContext, hPublicRootKey); 1518 hPublicRootKey = NULL_HKEY; 1519 return (CKR_FUNCTION_FAILED); 1520 } 1521 1522 /* create the SO's leaf key */ 1523 if ((rc = token_generate_leaf_key(hContext, TPMTOK_PUBLIC_LEAF_KEY, 1524 pinHash, &hPublicLeafKey))) { 1525 return (rc); 1526 } 1527 1528 if ((result = Tspi_Key_LoadKey(hPublicLeafKey, hPublicRootKey))) { 1529 stlogit("Tspi_Key_LoadKey: 0x%0x - %s", 1530 result, Trspi_Error_String(result)); 1531 1532 /* Unregister keys and clear UUIDs */ 1533 (void) Tspi_Context_UnregisterKey(hContext, 1534 TSS_PS_TYPE_USER, publicLeafKeyUUID, 1535 &hPublicLeafKey); 1536 (void) remove_uuid(TPMTOK_PUBLIC_LEAF_KEY_ID); 1537 1538 (void) Tspi_Context_UnregisterKey(hContext, 1539 TSS_PS_TYPE_USER, publicRootKeyUUID, 1540 &hPublicRootKey); 1541 (void) remove_uuid(TPMTOK_PUBLIC_ROOT_KEY_ID); 1542 1543 Tspi_Context_CloseObject(hContext, hPublicRootKey); 1544 hPublicRootKey = NULL_HKEY; 1545 1546 Tspi_Context_CloseObject(hContext, hPublicLeafKey); 1547 hPublicLeafKey = NULL_HKEY; 1548 1549 return (CKR_FUNCTION_FAILED); 1550 } 1551 1552 return (rc); 1553 } 1554 1555 CK_RV 1556 token_specific_login( 1557 TSS_HCONTEXT hContext, 1558 CK_USER_TYPE userType, 1559 CK_CHAR_PTR pPin, 1560 CK_ULONG ulPinLen) 1561 { 1562 CK_RV rc; 1563 CK_BYTE hash_sha[SHA1_DIGEST_LENGTH]; 1564 TSS_RESULT result; 1565 TSS_HKEY hSRK; 1566 1567 /* Make sure the SRK is loaded into the TPM */ 1568 if ((result = token_load_srk(hContext, &hSRK))) { 1569 return (CKR_FUNCTION_FAILED); 1570 } 1571 1572 if ((rc = compute_sha(pPin, ulPinLen, hash_sha))) { 1573 return (CKR_FUNCTION_FAILED); 1574 } 1575 1576 if (userType == CKU_USER) { 1577 /* 1578 * If the public root key doesn't exist yet, 1579 * the SO hasn't init'd the token. 1580 */ 1581 if ((result = token_load_public_root_key(hContext))) { 1582 if (result == TPM_E_DECRYPT_ERROR) { 1583 return (CKR_USER_PIN_NOT_INITIALIZED); 1584 } 1585 } 1586 1587 /* 1588 * - find privateRootKeyUUID 1589 * - load by UUID (SRK parent) 1590 */ 1591 if (local_uuid_is_null(&privateRootKeyUUID) && 1592 find_uuid(TPMTOK_PRIVATE_ROOT_KEY_ID, 1593 &privateRootKeyUUID)) { 1594 if (memcmp(hash_sha, 1595 default_user_pin_sha, 1596 SHA1_DIGEST_LENGTH)) 1597 return (CKR_PIN_INCORRECT); 1598 1599 not_initialized = 1; 1600 return (CKR_OK); 1601 } 1602 1603 if ((rc = verify_user_pin(hContext, hash_sha))) { 1604 return (rc); 1605 } 1606 1607 (void) memcpy(current_user_pin_sha, hash_sha, 1608 SHA1_DIGEST_LENGTH); 1609 1610 rc = load_private_token_objects(hContext); 1611 if (rc == CKR_OK) { 1612 (void) XProcLock(xproclock); 1613 global_shm->priv_loaded = TRUE; 1614 (void) XProcUnLock(xproclock); 1615 } 1616 } else { 1617 /* 1618 * SO login logic: 1619 * 1620 * - find publicRootKey UUID 1621 * - load by UUID wrap with hSRK from above 1622 */ 1623 if (local_uuid_is_null(&publicRootKeyUUID) && 1624 find_uuid(TPMTOK_PUBLIC_ROOT_KEY_ID, 1625 &publicRootKeyUUID)) { 1626 if (memcmp(hash_sha, 1627 default_so_pin_sha, 1628 SHA1_DIGEST_LENGTH)) 1629 return (CKR_PIN_INCORRECT); 1630 1631 not_initialized = 1; 1632 return (CKR_OK); 1633 1634 } 1635 if (hPublicRootKey == NULL_HKEY) { 1636 result = tss_find_and_load_key( 1637 hContext, 1638 TPMTOK_PUBLIC_ROOT_KEY_ID, 1639 &publicRootKeyUUID, hSRK, NULL, 1640 &hPublicRootKey); 1641 1642 if (result) 1643 return (CKR_FUNCTION_FAILED); 1644 } 1645 1646 /* find, load the public leaf key */ 1647 if (hPublicLeafKey == NULL_HKEY) { 1648 result = tss_find_and_load_key( 1649 hContext, 1650 TPMTOK_PUBLIC_LEAF_KEY_ID, 1651 &publicLeafKeyUUID, hPublicRootKey, hash_sha, 1652 &hPublicLeafKey); 1653 if (result) 1654 return (CKR_FUNCTION_FAILED); 1655 } 1656 1657 if ((rc = token_verify_pin(hContext, hPublicLeafKey))) { 1658 return (rc); 1659 } 1660 1661 (void) memcpy(current_so_pin_sha, hash_sha, SHA1_DIGEST_LENGTH); 1662 } 1663 1664 return (rc); 1665 } 1666 1667 CK_RV 1668 token_specific_logout(TSS_HCONTEXT hContext) 1669 { 1670 if (hPrivateLeafKey != NULL_HKEY) { 1671 Tspi_Key_UnloadKey(hPrivateLeafKey); 1672 hPrivateLeafKey = NULL_HKEY; 1673 } else if (hPublicLeafKey != NULL_HKEY) { 1674 Tspi_Key_UnloadKey(hPublicLeafKey); 1675 hPublicLeafKey = NULL_HKEY; 1676 } 1677 1678 local_uuid_clear(&publicRootKeyUUID); 1679 local_uuid_clear(&publicLeafKeyUUID); 1680 local_uuid_clear(&privateRootKeyUUID); 1681 local_uuid_clear(&privateLeafKeyUUID); 1682 1683 (void) memset(current_so_pin_sha, 0, SHA1_DIGEST_LENGTH); 1684 (void) memset(current_user_pin_sha, 0, SHA1_DIGEST_LENGTH); 1685 1686 (void) object_mgr_purge_private_token_objects(hContext); 1687 1688 return (CKR_OK); 1689 } 1690 1691 /*ARGSUSED*/ 1692 CK_RV 1693 token_specific_init_pin(TSS_HCONTEXT hContext, 1694 CK_CHAR_PTR pPin, CK_ULONG ulPinLen) 1695 { 1696 /* 1697 * Since the SO must log in before calling C_InitPIN, we will 1698 * be able to return (CKR_OK) automatically here. 1699 * This is because the USER key structure is created at the 1700 * time of their first login, not at C_InitPIN time. 1701 */ 1702 return (CKR_OK); 1703 } 1704 1705 static CK_RV 1706 check_pin_properties(CK_USER_TYPE userType, CK_BYTE *pinHash, 1707 CK_ULONG ulPinLen) 1708 { 1709 /* make sure the new PIN is different */ 1710 if (userType == CKU_USER) { 1711 if (!memcmp(pinHash, default_user_pin_sha, 1712 SHA1_DIGEST_LENGTH)) { 1713 LogError1("new PIN must not be the default"); 1714 return (CKR_PIN_INVALID); 1715 } 1716 } else { 1717 if (!memcmp(pinHash, default_so_pin_sha, 1718 SHA1_DIGEST_LENGTH)) { 1719 LogError1("new PIN must not be the default"); 1720 return (CKR_PIN_INVALID); 1721 } 1722 } 1723 1724 if (ulPinLen > MAX_PIN_LEN || ulPinLen < MIN_PIN_LEN) { 1725 LogError1("New PIN is out of size range"); 1726 return (CKR_PIN_LEN_RANGE); 1727 } 1728 1729 return (CKR_OK); 1730 } 1731 1732 /* 1733 * This function is called from set_pin only, where a non-logged-in public 1734 * session can provide the user pin which must be verified. This function 1735 * assumes that the pin has already been set once, so there's no migration 1736 * path option or checking of the default user pin. 1737 */ 1738 static CK_RV 1739 verify_user_pin(TSS_HCONTEXT hContext, CK_BYTE *hash_sha) 1740 { 1741 CK_RV rc; 1742 TSS_RESULT result; 1743 TSS_HKEY hSRK; 1744 1745 if (token_load_srk(hContext, &hSRK)) 1746 return (CKR_FUNCTION_FAILED); 1747 1748 /* 1749 * Verify the user by loading the privateLeafKey 1750 * into the TPM (if it's not already) and then 1751 * call the verify_pin operation. 1752 * 1753 * The hashed PIN is assigned to the private leaf key. 1754 * If it is incorrect (not the same as the one originally 1755 * used when the key was created), the verify operation 1756 * will fail. 1757 */ 1758 if (hPrivateRootKey == NULL_HKEY) { 1759 result = tss_find_and_load_key( 1760 hContext, 1761 TPMTOK_PRIVATE_ROOT_KEY_ID, 1762 &privateRootKeyUUID, hSRK, NULL, &hPrivateRootKey); 1763 if (result) 1764 return (CKR_FUNCTION_FAILED); 1765 } 1766 1767 if (hPrivateLeafKey == NULL_HKEY) { 1768 result = tss_find_and_load_key( 1769 hContext, 1770 TPMTOK_PRIVATE_LEAF_KEY_ID, 1771 &privateLeafKeyUUID, hPrivateRootKey, hash_sha, 1772 &hPrivateLeafKey); 1773 1774 if (result) 1775 return (CKR_FUNCTION_FAILED); 1776 } 1777 1778 /* 1779 * Verify that the PIN is correct by attempting to wrap/unwrap some 1780 * random data. 1781 */ 1782 if ((rc = token_verify_pin(hContext, hPrivateLeafKey))) { 1783 return (rc); 1784 } 1785 1786 return (CKR_OK); 1787 } 1788 1789 CK_RV 1790 token_specific_set_pin(ST_SESSION_HANDLE session, 1791 CK_CHAR_PTR pOldPin, CK_ULONG ulOldPinLen, 1792 CK_CHAR_PTR pNewPin, CK_ULONG ulNewPinLen) 1793 { 1794 SESSION *sess = session_mgr_find(session.sessionh); 1795 CK_BYTE oldpin_hash[SHA1_DIGEST_LENGTH]; 1796 CK_BYTE newpin_hash[SHA1_DIGEST_LENGTH]; 1797 CK_RV rc; 1798 TSS_HKEY hSRK; 1799 1800 if (!sess) { 1801 return (CKR_SESSION_HANDLE_INVALID); 1802 } 1803 1804 if ((rc = compute_sha(pOldPin, ulOldPinLen, oldpin_hash))) { 1805 return (CKR_FUNCTION_FAILED); 1806 } 1807 if ((rc = compute_sha(pNewPin, ulNewPinLen, newpin_hash))) { 1808 return (CKR_FUNCTION_FAILED); 1809 } 1810 1811 if (token_load_srk(sess->hContext, &hSRK)) { 1812 return (CKR_FUNCTION_FAILED); 1813 } 1814 1815 /* 1816 * From the PKCS#11 2.20 spec: "C_SetPIN modifies the PIN of 1817 * the user that is currently logged in, or the CKU_USER PIN 1818 * if the session is not logged in." 1819 * A non R/W session fails with CKR_SESSION_READ_ONLY. 1820 */ 1821 if (sess->session_info.state == CKS_RW_USER_FUNCTIONS || 1822 sess->session_info.state == CKS_RW_PUBLIC_SESSION) { 1823 if (not_initialized) { 1824 if (memcmp(oldpin_hash, default_user_pin_sha, 1825 SHA1_DIGEST_LENGTH)) { 1826 return (CKR_PIN_INCORRECT); 1827 } 1828 1829 if ((rc = check_pin_properties(CKU_USER, newpin_hash, 1830 ulNewPinLen))) { 1831 return (rc); 1832 } 1833 1834 if ((rc = token_create_private_tree(sess->hContext, 1835 newpin_hash))) { 1836 return (CKR_FUNCTION_FAILED); 1837 } 1838 1839 nv_token_data->token_info.flags &= 1840 ~(CKF_USER_PIN_TO_BE_CHANGED); 1841 nv_token_data->token_info.flags |= 1842 CKF_USER_PIN_INITIALIZED; 1843 1844 nv_token_data->token_info.flags &= 1845 ~(CKF_USER_PIN_TO_BE_CHANGED); 1846 nv_token_data->token_info.flags |= 1847 CKF_USER_PIN_INITIALIZED; 1848 1849 return (save_token_data(nv_token_data)); 1850 } 1851 1852 if (sess->session_info.state == CKS_RW_USER_FUNCTIONS) { 1853 /* if we're already logged in, just verify the hash */ 1854 if (memcmp(current_user_pin_sha, oldpin_hash, 1855 SHA1_DIGEST_LENGTH)) { 1856 return (CKR_PIN_INCORRECT); 1857 } 1858 } else { 1859 if ((rc = verify_user_pin(sess->hContext, 1860 oldpin_hash))) { 1861 return (rc); 1862 } 1863 } 1864 1865 if ((rc = check_pin_properties(CKU_USER, newpin_hash, 1866 ulNewPinLen))) 1867 return (rc); 1868 1869 /* change the auth on the TSS object */ 1870 if (tss_change_auth(sess->hContext, 1871 hPrivateLeafKey, hPrivateRootKey, 1872 privateLeafKeyUUID, privateRootKeyUUID, 1873 newpin_hash)) 1874 return (CKR_FUNCTION_FAILED); 1875 1876 } else if (sess->session_info.state == CKS_RW_SO_FUNCTIONS) { 1877 if (not_initialized) { 1878 if (memcmp(default_so_pin_sha, oldpin_hash, 1879 SHA1_DIGEST_LENGTH)) 1880 return (CKR_PIN_INCORRECT); 1881 1882 if ((rc = check_pin_properties(CKU_SO, 1883 newpin_hash, ulNewPinLen))) 1884 return (rc); 1885 1886 if ((rc = token_create_public_tree(sess->hContext, 1887 newpin_hash))) 1888 return (CKR_FUNCTION_FAILED); 1889 1890 nv_token_data->token_info.flags &= 1891 ~(CKF_SO_PIN_TO_BE_CHANGED); 1892 1893 return (save_token_data(nv_token_data)); 1894 } 1895 1896 if (memcmp(current_so_pin_sha, oldpin_hash, 1897 SHA1_DIGEST_LENGTH)) 1898 return (CKR_PIN_INCORRECT); 1899 1900 if ((rc = check_pin_properties(CKU_SO, newpin_hash, 1901 ulNewPinLen))) 1902 return (rc); 1903 1904 /* change auth on the SO's leaf key */ 1905 if (tss_change_auth(sess->hContext, 1906 hPublicLeafKey, hPublicRootKey, 1907 publicLeafKeyUUID, publicRootKeyUUID, 1908 newpin_hash)) 1909 return (CKR_FUNCTION_FAILED); 1910 1911 } else { 1912 rc = CKR_SESSION_READ_ONLY; 1913 } 1914 1915 return (rc); 1916 } 1917 1918 /* only called at token init time */ 1919 CK_RV 1920 token_specific_verify_so_pin(TSS_HCONTEXT hContext, CK_CHAR_PTR pPin, 1921 CK_ULONG ulPinLen) 1922 { 1923 CK_BYTE hash_sha[SHA1_DIGEST_LENGTH]; 1924 CK_RV rc; 1925 TSS_RESULT result; 1926 TSS_HKEY hSRK; 1927 1928 if ((rc = compute_sha(pPin, ulPinLen, hash_sha))) { 1929 return (CKR_FUNCTION_FAILED); 1930 } 1931 if ((rc = token_load_srk(hContext, &hSRK))) { 1932 return (CKR_FUNCTION_FAILED); 1933 } 1934 1935 /* 1936 * TRYME INSTEAD: 1937 * - find publicRootKeyUUID 1938 * - Load publicRootKey by UUID (SRK parent) 1939 * - find publicLeafKeyUUID 1940 * - Load publicLeafKey by UUID (publicRootKey parent) 1941 * - set password policy on publicLeafKey 1942 */ 1943 if (local_uuid_is_null(&publicRootKeyUUID) && 1944 find_uuid(TPMTOK_PUBLIC_ROOT_KEY_ID, &publicRootKeyUUID)) { 1945 /* 1946 * The SO hasn't set their PIN yet, compare the 1947 * login pin with the hard-coded value. 1948 */ 1949 if (memcmp(default_so_pin_sha, hash_sha, 1950 SHA1_DIGEST_LENGTH)) { 1951 return (CKR_PIN_INCORRECT); 1952 } 1953 return (CKR_OK); 1954 } 1955 1956 result = Tspi_Context_GetKeyByUUID(hContext, 1957 TSS_PS_TYPE_USER, publicRootKeyUUID, &hPublicRootKey); 1958 1959 if (result) 1960 return (CKR_FUNCTION_FAILED); 1961 1962 result = Tspi_Key_LoadKey(hPublicRootKey, hSRK); 1963 if (result) 1964 return (CKR_FUNCTION_FAILED); 1965 1966 if (local_uuid_is_null(&publicLeafKeyUUID) && 1967 find_uuid(TPMTOK_PUBLIC_LEAF_KEY_ID, &publicLeafKeyUUID)) 1968 return (CKR_FUNCTION_FAILED); 1969 1970 result = Tspi_Context_GetKeyByUUID(hContext, 1971 TSS_PS_TYPE_USER, publicLeafKeyUUID, &hPublicLeafKey); 1972 if (result) 1973 return (CKR_FUNCTION_FAILED); 1974 1975 result = tss_assign_secret_key_policy(hContext, TSS_POLICY_USAGE, 1976 hPublicLeafKey, hash_sha); 1977 if (result) 1978 return (CKR_FUNCTION_FAILED); 1979 1980 result = Tspi_Key_LoadKey(hPublicLeafKey, hPublicRootKey); 1981 if (result) 1982 return (CKR_FUNCTION_FAILED); 1983 1984 /* If the hash given is wrong, the verify will fail */ 1985 if ((rc = token_verify_pin(hContext, hPublicLeafKey))) { 1986 return (rc); 1987 } 1988 1989 return (CKR_OK); 1990 } 1991 1992 CK_RV 1993 token_specific_final(TSS_HCONTEXT hContext) 1994 { 1995 if (hPublicRootKey != NULL_HKEY) { 1996 Tspi_Context_CloseObject(hContext, hPublicRootKey); 1997 hPublicRootKey = NULL_HKEY; 1998 } 1999 if (hPublicLeafKey != NULL_HKEY) { 2000 Tspi_Context_CloseObject(hContext, hPublicLeafKey); 2001 hPublicLeafKey = NULL_HKEY; 2002 } 2003 if (hPrivateRootKey != NULL_HKEY) { 2004 Tspi_Context_CloseObject(hContext, hPrivateRootKey); 2005 hPrivateRootKey = NULL_HKEY; 2006 } 2007 if (hPrivateLeafKey != NULL_HKEY) { 2008 Tspi_Context_CloseObject(hContext, hPrivateLeafKey); 2009 hPrivateLeafKey = NULL_HKEY; 2010 } 2011 return (CKR_OK); 2012 } 2013 2014 /* 2015 * Wrap the 20 bytes of auth data and store in an attribute of the two 2016 * keys. 2017 */ 2018 static CK_RV 2019 token_wrap_auth_data(TSS_HCONTEXT hContext, 2020 CK_BYTE *authData, TEMPLATE *publ_tmpl, 2021 TEMPLATE *priv_tmpl) 2022 { 2023 CK_RV rc; 2024 CK_ATTRIBUTE *new_attr; 2025 2026 TSS_RESULT ret; 2027 TSS_HKEY hParentKey; 2028 TSS_HENCDATA hEncData; 2029 BYTE *blob; 2030 UINT32 blob_size; 2031 2032 if ((hPrivateLeafKey == NULL_HKEY) && (hPublicLeafKey == NULL_HKEY)) { 2033 return (CKR_FUNCTION_FAILED); 2034 } else if (hPublicLeafKey != NULL_HKEY) { 2035 hParentKey = hPublicLeafKey; 2036 } else { 2037 hParentKey = hPrivateLeafKey; 2038 } 2039 2040 /* create the encrypted data object */ 2041 if ((ret = Tspi_Context_CreateObject(hContext, 2042 TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND, &hEncData))) { 2043 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 2044 ret, Trspi_Error_String(ret)); 2045 return (CKR_FUNCTION_FAILED); 2046 } 2047 2048 if ((ret = Tspi_Data_Bind(hEncData, hParentKey, SHA1_DIGEST_LENGTH, 2049 authData))) { 2050 stlogit("Tspi_Data_Bind: 0x%0x - %s", 2051 ret, Trspi_Error_String(ret)); 2052 return (CKR_FUNCTION_FAILED); 2053 } 2054 2055 /* pull the encrypted data out of the encrypted data object */ 2056 if ((ret = Tspi_GetAttribData(hEncData, TSS_TSPATTRIB_ENCDATA_BLOB, 2057 TSS_TSPATTRIB_ENCDATABLOB_BLOB, &blob_size, &blob))) { 2058 stlogit("Tspi_SetAttribData: 0x%0x - %s", 2059 ret, Trspi_Error_String(ret)); 2060 return (CKR_FUNCTION_FAILED); 2061 } 2062 2063 if ((rc = build_attribute(CKA_ENC_AUTHDATA, blob, blob_size, 2064 &new_attr))) { 2065 return (rc); 2066 } 2067 (void) template_update_attribute(publ_tmpl, new_attr); 2068 2069 if ((rc = build_attribute(CKA_ENC_AUTHDATA, blob, 2070 blob_size, &new_attr))) { 2071 return (rc); 2072 } 2073 (void) template_update_attribute(priv_tmpl, new_attr); 2074 2075 return (rc); 2076 } 2077 2078 static CK_RV 2079 token_unwrap_auth_data(TSS_HCONTEXT hContext, CK_BYTE *encAuthData, 2080 CK_ULONG encAuthDataLen, TSS_HKEY hKey, 2081 BYTE **authData) 2082 { 2083 TSS_RESULT result; 2084 TSS_HENCDATA hEncData; 2085 BYTE *buf; 2086 UINT32 buf_size; 2087 2088 if ((result = Tspi_Context_CreateObject(hContext, 2089 TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND, &hEncData))) { 2090 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 2091 result, Trspi_Error_String(result)); 2092 return (CKR_FUNCTION_FAILED); 2093 } 2094 2095 if ((result = Tspi_SetAttribData(hEncData, 2096 TSS_TSPATTRIB_ENCDATA_BLOB, TSS_TSPATTRIB_ENCDATABLOB_BLOB, 2097 encAuthDataLen, encAuthData))) { 2098 stlogit("Tspi_SetAttribData: 0x%0x - %s", 2099 result, Trspi_Error_String(result)); 2100 return (CKR_FUNCTION_FAILED); 2101 } 2102 2103 /* unbind the data, receiving the plaintext back */ 2104 if ((result = Tspi_Data_Unbind(hEncData, hKey, &buf_size, &buf))) { 2105 stlogit("Tspi_Data_Unbind: 0x%0x - %s", 2106 result, Trspi_Error_String(result)); 2107 return (CKR_FUNCTION_FAILED); 2108 } 2109 2110 if (buf_size != SHA1_DIGEST_LENGTH) { 2111 return (CKR_FUNCTION_FAILED); 2112 } 2113 2114 *authData = buf; 2115 2116 return (CKR_OK); 2117 } 2118 2119 CK_RV 2120 token_specific_rsa_generate_keypair( 2121 TSS_HCONTEXT hContext, 2122 TEMPLATE *publ_tmpl, 2123 TEMPLATE *priv_tmpl) 2124 { 2125 CK_ATTRIBUTE *attr = NULL; 2126 CK_ULONG mod_bits = 0; 2127 CK_BBOOL flag; 2128 CK_RV rc; 2129 2130 TSS_FLAG initFlags = 0; 2131 BYTE authHash[SHA1_DIGEST_LENGTH]; 2132 BYTE *authData = NULL; 2133 TSS_HKEY hKey = NULL_HKEY; 2134 TSS_HKEY hParentKey = NULL_HKEY; 2135 TSS_RESULT result; 2136 UINT32 ulBlobLen; 2137 BYTE *rgbBlob; 2138 2139 /* Make sure the public exponent is usable */ 2140 if ((util_check_public_exponent(publ_tmpl))) { 2141 return (CKR_TEMPLATE_INCONSISTENT); 2142 } 2143 2144 flag = template_attribute_find(publ_tmpl, CKA_MODULUS_BITS, &attr); 2145 if (!flag) { 2146 return (CKR_TEMPLATE_INCOMPLETE); 2147 } 2148 mod_bits = *(CK_ULONG *)attr->pValue; 2149 2150 if ((initFlags = util_get_keysize_flag(mod_bits)) == 0) { 2151 return (CKR_KEY_SIZE_RANGE); 2152 } 2153 2154 /* 2155 * If we're not logged in, hPrivateLeafKey and hPublicLeafKey 2156 * should be NULL. 2157 */ 2158 if ((hPrivateLeafKey == NULL_HKEY) && 2159 (hPublicLeafKey == NULL_HKEY)) { 2160 /* public session, wrap key with the PRK */ 2161 initFlags |= TSS_KEY_TYPE_LEGACY | 2162 TSS_KEY_NO_AUTHORIZATION | TSS_KEY_MIGRATABLE; 2163 2164 if ((result = token_load_public_root_key(hContext))) { 2165 return (CKR_FUNCTION_FAILED); 2166 } 2167 2168 hParentKey = hPublicRootKey; 2169 } else if (hPrivateLeafKey != NULL_HKEY) { 2170 /* logged in USER session */ 2171 initFlags |= TSS_KEY_TYPE_LEGACY | 2172 TSS_KEY_AUTHORIZATION | TSS_KEY_MIGRATABLE; 2173 2174 /* get a random SHA1 hash for the auth data */ 2175 if ((rc = token_rng(hContext, authHash, SHA1_DIGEST_LENGTH))) { 2176 return (CKR_FUNCTION_FAILED); 2177 } 2178 2179 authData = authHash; 2180 hParentKey = hPrivateRootKey; 2181 } else { 2182 /* logged in SO session */ 2183 initFlags |= TSS_KEY_TYPE_LEGACY | 2184 TSS_KEY_AUTHORIZATION | TSS_KEY_MIGRATABLE; 2185 2186 /* get a random SHA1 hash for the auth data */ 2187 if ((rc = token_rng(hContext, authHash, SHA1_DIGEST_LENGTH))) { 2188 return (CKR_FUNCTION_FAILED); 2189 } 2190 2191 authData = authHash; 2192 hParentKey = hPublicRootKey; 2193 } 2194 2195 if ((result = tss_generate_key(hContext, initFlags, authData, 2196 hParentKey, &hKey))) { 2197 return (result); 2198 } 2199 2200 if ((result = Tspi_GetAttribData(hKey, TSS_TSPATTRIB_KEY_BLOB, 2201 TSS_TSPATTRIB_KEYBLOB_BLOB, &ulBlobLen, &rgbBlob))) { 2202 stlogit("Tspi_GetAttribData: 0x%0x - %s", 2203 result, Trspi_Error_String(result)); 2204 return (CKR_FUNCTION_FAILED); 2205 } 2206 2207 if ((rc = build_attribute(CKA_IBM_OPAQUE, rgbBlob, 2208 ulBlobLen, &attr))) { 2209 Tspi_Context_FreeMemory(hContext, rgbBlob); 2210 return (rc); 2211 } 2212 (void) template_update_attribute(priv_tmpl, attr); 2213 if ((rc = build_attribute(CKA_IBM_OPAQUE, rgbBlob, 2214 ulBlobLen, &attr))) { 2215 Tspi_Context_FreeMemory(hContext, rgbBlob); 2216 return (rc); 2217 } 2218 (void) template_update_attribute(publ_tmpl, attr); 2219 2220 Tspi_Context_FreeMemory(hContext, rgbBlob); 2221 2222 /* grab the public key to put into the public key object */ 2223 if ((result = Tspi_GetAttribData(hKey, TSS_TSPATTRIB_RSAKEY_INFO, 2224 TSS_TSPATTRIB_KEYINFO_RSA_MODULUS, &ulBlobLen, &rgbBlob))) { 2225 stlogit("Tspi_GetAttribData: 0x%0x - %s", 2226 result, Trspi_Error_String(result)); 2227 return (result); 2228 } 2229 2230 /* add the public key blob to the object template */ 2231 if ((rc = build_attribute(CKA_MODULUS, rgbBlob, ulBlobLen, &attr))) { 2232 Tspi_Context_FreeMemory(hContext, rgbBlob); 2233 return (rc); 2234 } 2235 (void) template_update_attribute(publ_tmpl, attr); 2236 2237 /* add the public key blob to the object template */ 2238 if ((rc = build_attribute(CKA_MODULUS, rgbBlob, ulBlobLen, &attr))) { 2239 Tspi_Context_FreeMemory(hContext, rgbBlob); 2240 return (rc); 2241 } 2242 (void) template_update_attribute(priv_tmpl, attr); 2243 Tspi_Context_FreeMemory(hContext, rgbBlob); 2244 2245 /* wrap the authdata and put it into an object */ 2246 if (authData != NULL) { 2247 rc = token_wrap_auth_data(hContext, authData, publ_tmpl, 2248 priv_tmpl); 2249 } 2250 2251 return (rc); 2252 } 2253 2254 static CK_RV 2255 token_rsa_load_key( 2256 TSS_HCONTEXT hContext, 2257 OBJECT *key_obj, 2258 TSS_HKEY *phKey) 2259 { 2260 TSS_RESULT result; 2261 TSS_HPOLICY hPolicy = NULL_HPOLICY; 2262 TSS_HKEY hParentKey; 2263 BYTE *authData = NULL; 2264 CK_ATTRIBUTE *attr; 2265 CK_RV rc; 2266 CK_OBJECT_HANDLE handle; 2267 CK_ULONG class; 2268 2269 if (hPrivateLeafKey != NULL_HKEY) { 2270 hParentKey = hPrivateRootKey; 2271 } else { 2272 if ((result = token_load_public_root_key(hContext))) 2273 return (CKR_FUNCTION_FAILED); 2274 2275 hParentKey = hPublicRootKey; 2276 } 2277 2278 *phKey = 0; 2279 if (template_attribute_find(key_obj->template, CKA_CLASS, 2280 &attr) == FALSE) { 2281 return (CKR_TEMPLATE_INCOMPLETE); 2282 } 2283 class = *((CK_ULONG *)attr->pValue); 2284 2285 rc = template_attribute_find(key_obj->template, 2286 CKA_IBM_OPAQUE, &attr); 2287 /* 2288 * A public key cannot use the OPAQUE data attribute so they 2289 * must be created in software. A private key may not yet 2290 * have its "opaque" data defined and needs to be created 2291 * and loaded so it can be used inside the TPM. 2292 */ 2293 if (class == CKO_PUBLIC_KEY || rc == FALSE) { 2294 rc = object_mgr_find_in_map2(hContext, key_obj, &handle); 2295 if (rc != CKR_OK) 2296 return (CKR_FUNCTION_FAILED); 2297 2298 if ((rc = token_load_key(hContext, 2299 handle, hParentKey, NULL, phKey))) { 2300 return (rc); 2301 } 2302 } 2303 /* 2304 * If this is a private key, get the blob and load it in the TPM. 2305 * If it is public, the key is already loaded in software. 2306 */ 2307 if (class == CKO_PRIVATE_KEY) { 2308 /* If we already have a handle, just load it */ 2309 if (*phKey != 0) { 2310 result = Tspi_Key_LoadKey(*phKey, hParentKey); 2311 if (result) { 2312 stlogit("Tspi_Context_LoadKeyByBlob: " 2313 "0x%0x - %s", 2314 result, Trspi_Error_String(result)); 2315 return (CKR_FUNCTION_FAILED); 2316 } 2317 } else { 2318 /* try again to get the CKA_IBM_OPAQUE attr */ 2319 if ((rc = template_attribute_find(key_obj->template, 2320 CKA_IBM_OPAQUE, &attr)) == FALSE) { 2321 return (rc); 2322 } 2323 if ((result = Tspi_Context_LoadKeyByBlob(hContext, 2324 hParentKey, attr->ulValueLen, attr->pValue, 2325 phKey))) { 2326 stlogit("Tspi_Context_LoadKeyByBlob: " 2327 "0x%0x - %s", 2328 result, Trspi_Error_String(result)); 2329 return (CKR_FUNCTION_FAILED); 2330 } 2331 } 2332 } 2333 2334 /* auth data may be required */ 2335 if (template_attribute_find(key_obj->template, CKA_ENC_AUTHDATA, 2336 &attr) == TRUE && attr) { 2337 if ((hPrivateLeafKey == NULL_HKEY) && 2338 (hPublicLeafKey == NULL_HKEY)) { 2339 return (CKR_FUNCTION_FAILED); 2340 } else if (hPublicLeafKey != NULL_HKEY) { 2341 hParentKey = hPublicLeafKey; 2342 } else { 2343 hParentKey = hPrivateLeafKey; 2344 } 2345 2346 if ((result = token_unwrap_auth_data(hContext, 2347 attr->pValue, attr->ulValueLen, 2348 hParentKey, &authData))) { 2349 return (CKR_FUNCTION_FAILED); 2350 } 2351 2352 if ((result = Tspi_GetPolicyObject(*phKey, 2353 TSS_POLICY_USAGE, &hPolicy))) { 2354 stlogit("Tspi_GetPolicyObject: 0x%0x - %s", 2355 result, Trspi_Error_String(result)); 2356 return (CKR_FUNCTION_FAILED); 2357 } 2358 2359 /* 2360 * If the policy handle returned is the same as the 2361 * context's default policy, then a new policy must 2362 * be created and assigned to the key. Otherwise, just set the 2363 * secret in the policy. 2364 */ 2365 if (hPolicy == hDefaultPolicy) { 2366 if ((result = Tspi_Context_CreateObject(hContext, 2367 TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, 2368 &hPolicy))) { 2369 stlogit("Tspi_Context_CreateObject: " 2370 "0x%0x - %s", 2371 result, Trspi_Error_String(result)); 2372 return (CKR_FUNCTION_FAILED); 2373 } 2374 2375 if ((result = Tspi_Policy_SetSecret(hPolicy, 2376 TSS_SECRET_MODE_SHA1, 2377 SHA1_DIGEST_LENGTH, authData))) { 2378 stlogit("Tspi_Policy_SetSecret: " 2379 "0x%0x - %s", 2380 result, Trspi_Error_String(result)); 2381 return (CKR_FUNCTION_FAILED); 2382 } 2383 2384 if ((result = Tspi_Policy_AssignToObject(hPolicy, 2385 *phKey))) { 2386 stlogit("Tspi_Policy_AssignToObject: " 2387 "0x%0x - %s", 2388 result, Trspi_Error_String(result)); 2389 return (CKR_FUNCTION_FAILED); 2390 } 2391 } else if ((result = Tspi_Policy_SetSecret(hPolicy, 2392 TSS_SECRET_MODE_SHA1, SHA1_DIGEST_LENGTH, authData))) { 2393 stlogit("Tspi_Policy_SetSecret: 0x%0x - %s", 2394 result, Trspi_Error_String(result)); 2395 return (CKR_FUNCTION_FAILED); 2396 } 2397 2398 Tspi_Context_FreeMemory(hContext, authData); 2399 } 2400 2401 return (CKR_OK); 2402 } 2403 2404 CK_RV 2405 tpm_decrypt_data( 2406 TSS_HCONTEXT hContext, 2407 TSS_HKEY hKey, 2408 CK_BYTE * in_data, 2409 CK_ULONG in_data_len, 2410 CK_BYTE * out_data, 2411 CK_ULONG * out_data_len) 2412 { 2413 TSS_RESULT result; 2414 TSS_HENCDATA hEncData = NULL_HENCDATA; 2415 UINT32 buf_size = 0, modLen; 2416 BYTE *buf = NULL, *modulus = NULL; 2417 CK_ULONG chunklen, remain, outlen; 2418 2419 /* push the data into the encrypted data object */ 2420 if ((result = Tspi_Context_CreateObject(hContext, 2421 TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND, &hEncData))) { 2422 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 2423 result, Trspi_Error_String(result)); 2424 return (CKR_FUNCTION_FAILED); 2425 } 2426 2427 /* 2428 * Figure out the modulus size so we can break the data 2429 * into smaller chunks if necessary. 2430 */ 2431 if ((result = Tspi_GetAttribData(hKey, TSS_TSPATTRIB_RSAKEY_INFO, 2432 TSS_TSPATTRIB_KEYINFO_RSA_MODULUS, &modLen, &modulus))) { 2433 stlogit("Tspi_GetAttribData: 0x%0x - %s", 2434 result, Trspi_Error_String(result)); 2435 return (result); 2436 } 2437 /* we don't need the actual modulus */ 2438 Tspi_Context_FreeMemory(hContext, modulus); 2439 2440 chunklen = (in_data_len > modLen ? modLen : in_data_len); 2441 remain = in_data_len; 2442 outlen = 0; 2443 2444 while (remain > 0) { 2445 if ((result = Tspi_SetAttribData(hEncData, 2446 TSS_TSPATTRIB_ENCDATA_BLOB, 2447 TSS_TSPATTRIB_ENCDATABLOB_BLOB, 2448 chunklen, in_data))) { 2449 stlogit("Tspi_SetAttribData: 0x%0x - %s", 2450 result, Trspi_Error_String(result)); 2451 return (CKR_FUNCTION_FAILED); 2452 } 2453 2454 /* unbind the data, receiving the plaintext back */ 2455 if ((result = Tspi_Data_Unbind(hEncData, hKey, 2456 &buf_size, &buf))) { 2457 stlogit("Tspi_Data_Unbind: 0x%0x - %s", 2458 result, Trspi_Error_String(result)); 2459 return (CKR_FUNCTION_FAILED); 2460 } 2461 2462 if (*out_data_len < buf_size + outlen) { 2463 Tspi_Context_FreeMemory(hContext, buf); 2464 return (CKR_BUFFER_TOO_SMALL); 2465 } 2466 2467 (void) memcpy(out_data + outlen, buf, buf_size); 2468 2469 outlen += buf_size; 2470 in_data += chunklen; 2471 remain -= chunklen; 2472 2473 Tspi_Context_FreeMemory(hContext, buf); 2474 if (chunklen > remain) 2475 chunklen = remain; 2476 } 2477 *out_data_len = outlen; 2478 return (CKR_OK); 2479 } 2480 2481 CK_RV 2482 token_specific_rsa_decrypt( 2483 TSS_HCONTEXT hContext, 2484 CK_BYTE * in_data, 2485 CK_ULONG in_data_len, 2486 CK_BYTE * out_data, 2487 CK_ULONG * out_data_len, 2488 OBJECT * key_obj) 2489 { 2490 CK_RV rc; 2491 TSS_HKEY hKey; 2492 2493 if ((rc = token_rsa_load_key(hContext, key_obj, &hKey))) { 2494 return (rc); 2495 } 2496 2497 rc = tpm_decrypt_data(hContext, hKey, in_data, in_data_len, 2498 out_data, out_data_len); 2499 2500 return (rc); 2501 } 2502 2503 CK_RV 2504 token_specific_rsa_verify( 2505 TSS_HCONTEXT hContext, 2506 CK_BYTE * in_data, 2507 CK_ULONG in_data_len, 2508 CK_BYTE * sig, 2509 CK_ULONG sig_len, 2510 OBJECT * key_obj) 2511 { 2512 TSS_RESULT result; 2513 TSS_HHASH hHash; 2514 TSS_HKEY hKey; 2515 CK_RV rc; 2516 2517 if ((rc = token_rsa_load_key(hContext, key_obj, &hKey))) { 2518 return (rc); 2519 } 2520 2521 /* Create the hash object we'll use to sign */ 2522 if ((result = Tspi_Context_CreateObject(hContext, 2523 TSS_OBJECT_TYPE_HASH, TSS_HASH_OTHER, &hHash))) { 2524 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 2525 result, Trspi_Error_String(result)); 2526 return (CKR_FUNCTION_FAILED); 2527 } 2528 2529 /* Insert the data into the hash object */ 2530 if ((result = Tspi_Hash_SetHashValue(hHash, in_data_len, 2531 in_data))) { 2532 stlogit("Tspi_Hash_SetHashValue: 0x%0x - %s", 2533 result, Trspi_Error_String(result)); 2534 return (CKR_FUNCTION_FAILED); 2535 } 2536 2537 /* Verify */ 2538 result = Tspi_Hash_VerifySignature(hHash, hKey, sig_len, sig); 2539 if (result != TSS_SUCCESS && 2540 TPMTOK_TSS_ERROR_CODE(result) != TSS_E_FAIL) { 2541 stlogit("Tspi_Hash_VerifySignature: 0x%0x - %s", 2542 result, Trspi_Error_String(result)); 2543 } 2544 2545 if (TPMTOK_TSS_ERROR_CODE(result) == TSS_E_FAIL) { 2546 rc = CKR_SIGNATURE_INVALID; 2547 } else { 2548 rc = CKR_OK; 2549 } 2550 2551 return (rc); 2552 } 2553 2554 CK_RV 2555 token_specific_rsa_sign( 2556 TSS_HCONTEXT hContext, 2557 CK_BYTE * in_data, 2558 CK_ULONG in_data_len, 2559 CK_BYTE * out_data, 2560 CK_ULONG * out_data_len, 2561 OBJECT * key_obj) 2562 { 2563 TSS_RESULT result; 2564 TSS_HHASH hHash; 2565 BYTE *sig; 2566 UINT32 sig_len; 2567 TSS_HKEY hKey; 2568 CK_RV rc; 2569 2570 if ((rc = token_rsa_load_key(hContext, key_obj, &hKey))) { 2571 return (rc); 2572 } 2573 2574 /* Create the hash object we'll use to sign */ 2575 if ((result = Tspi_Context_CreateObject(hContext, 2576 TSS_OBJECT_TYPE_HASH, TSS_HASH_OTHER, &hHash))) { 2577 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 2578 result, Trspi_Error_String(result)); 2579 return (CKR_FUNCTION_FAILED); 2580 } 2581 2582 /* Insert the data into the hash object */ 2583 if ((result = Tspi_Hash_SetHashValue(hHash, in_data_len, 2584 in_data))) { 2585 stlogit("Tspi_Hash_SetHashValue: 0x%0x - %s", 2586 result, Trspi_Error_String(result)); 2587 return (CKR_FUNCTION_FAILED); 2588 } 2589 2590 /* Sign */ 2591 if ((result = Tspi_Hash_Sign(hHash, hKey, &sig_len, &sig))) { 2592 stlogit("Tspi_Hash_Sign: 0x%0x - %s", 2593 result, Trspi_Error_String(result)); 2594 return (CKR_DATA_LEN_RANGE); 2595 } 2596 2597 if (sig_len > *out_data_len) { 2598 Tspi_Context_FreeMemory(hContext, sig); 2599 return (CKR_BUFFER_TOO_SMALL); 2600 } 2601 2602 (void) memcpy(out_data, sig, sig_len); 2603 *out_data_len = sig_len; 2604 Tspi_Context_FreeMemory(hContext, sig); 2605 2606 return (CKR_OK); 2607 } 2608 2609 CK_RV 2610 tpm_encrypt_data( 2611 TSS_HCONTEXT hContext, 2612 TSS_HKEY hKey, 2613 CK_BYTE *in_data, 2614 CK_ULONG in_data_len, 2615 CK_BYTE *out_data, 2616 CK_ULONG *out_data_len) 2617 { 2618 TSS_RESULT result; 2619 TSS_HENCDATA hEncData; 2620 BYTE *dataBlob, *modulus; 2621 UINT32 dataBlobSize, modLen; 2622 CK_ULONG chunklen, remain; 2623 CK_ULONG outlen; 2624 UINT32 keyusage, scheme, maxsize; 2625 2626 if ((result = Tspi_Context_CreateObject(hContext, 2627 TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND, &hEncData))) { 2628 stlogit("Tspi_Context_CreateObject: 0x%0x - %s", 2629 result, Trspi_Error_String(result)); 2630 return (CKR_FUNCTION_FAILED); 2631 } 2632 /* 2633 * Figure out the modulus size so we can break the data 2634 * into smaller chunks if necessary. 2635 */ 2636 if ((result = Tspi_GetAttribData(hKey, TSS_TSPATTRIB_RSAKEY_INFO, 2637 TSS_TSPATTRIB_KEYINFO_RSA_MODULUS, &modLen, &modulus))) { 2638 stlogit("Tspi_GetAttribData: 0x%0x - %s", 2639 result, Trspi_Error_String(result)); 2640 return (result); 2641 } 2642 /* we don't need the actual modulus */ 2643 Tspi_Context_FreeMemory(hContext, modulus); 2644 2645 /* 2646 * According to TSS spec for Tspi_Data_Bind (4.3.4.21.5), 2647 * Max input data size varies depending on the key type and 2648 * encryption scheme. 2649 */ 2650 if ((result = Tspi_GetAttribUint32(hKey, TSS_TSPATTRIB_KEY_INFO, 2651 TSS_TSPATTRIB_KEYINFO_USAGE, &keyusage))) { 2652 stlogit("Cannot find USAGE: %s\n", 2653 Trspi_Error_String(result)); 2654 return (result); 2655 } 2656 if ((result = Tspi_GetAttribUint32(hKey, TSS_TSPATTRIB_KEY_INFO, 2657 TSS_TSPATTRIB_KEYINFO_ENCSCHEME, &scheme))) { 2658 stlogit("Cannot find ENCSCHEME: %s\n", 2659 Trspi_Error_String(result)); 2660 return (result); 2661 } 2662 switch (scheme) { 2663 case TSS_ES_RSAESPKCSV15: 2664 if (keyusage == TSS_KEYUSAGE_BIND) 2665 maxsize = 16; 2666 else /* legacy */ 2667 maxsize = 11; 2668 break; 2669 case TSS_ES_RSAESOAEP_SHA1_MGF1: 2670 maxsize = 47; 2671 break; 2672 default: 2673 maxsize = 0; 2674 } 2675 2676 modLen -= maxsize; 2677 2678 chunklen = (in_data_len > modLen ? modLen : in_data_len); 2679 remain = in_data_len; 2680 outlen = 0; 2681 while (remain > 0) { 2682 if ((result = Tspi_Data_Bind(hEncData, hKey, 2683 chunklen, in_data))) { 2684 stlogit("Tspi_Data_Bind: 0x%0x - %s", 2685 result, Trspi_Error_String(result)); 2686 return (CKR_FUNCTION_FAILED); 2687 } 2688 2689 if ((result = Tspi_GetAttribData(hEncData, 2690 TSS_TSPATTRIB_ENCDATA_BLOB, 2691 TSS_TSPATTRIB_ENCDATABLOB_BLOB, 2692 &dataBlobSize, &dataBlob))) { 2693 stlogit("Tspi_GetAttribData: 0x%0x - %s", 2694 result, Trspi_Error_String(result)); 2695 return (CKR_FUNCTION_FAILED); 2696 } 2697 2698 if (outlen + dataBlobSize > *out_data_len) { 2699 Tspi_Context_FreeMemory(hContext, dataBlob); 2700 return (CKR_DATA_LEN_RANGE); 2701 } 2702 2703 (void) memcpy(out_data + outlen, 2704 dataBlob, dataBlobSize); 2705 2706 outlen += dataBlobSize; 2707 in_data += chunklen; 2708 remain -= chunklen; 2709 2710 if (chunklen > remain) 2711 chunklen = remain; 2712 2713 Tspi_Context_FreeMemory(hContext, dataBlob); 2714 } 2715 *out_data_len = outlen; 2716 2717 return (CKR_OK); 2718 } 2719 2720 CK_RV 2721 token_specific_rsa_encrypt( 2722 TSS_HCONTEXT hContext, 2723 CK_BYTE * in_data, 2724 CK_ULONG in_data_len, 2725 CK_BYTE * out_data, 2726 CK_ULONG * out_data_len, 2727 OBJECT * key_obj) 2728 { 2729 TSS_HKEY hKey; 2730 CK_RV rc; 2731 2732 if ((rc = token_rsa_load_key(hContext, key_obj, &hKey))) { 2733 return (rc); 2734 } 2735 2736 rc = tpm_encrypt_data(hContext, hKey, in_data, in_data_len, 2737 out_data, out_data_len); 2738 2739 return (rc); 2740 } 2741 2742 /* 2743 * RSA Verify Recover 2744 * 2745 * Public key crypto is done in software, not by the TPM. 2746 * We use libsoftcrypto and perform the RSA operations ourselves similar 2747 * to how pkcs11_softtoken performs the operation. 2748 */ 2749 CK_RV 2750 token_specific_rsa_verify_recover( 2751 TSS_HCONTEXT hContext, 2752 CK_BYTE_PTR pSignature, 2753 CK_ULONG ulSignatureLen, 2754 CK_BYTE_PTR pData, 2755 CK_ULONG_PTR pulDataLen, 2756 OBJECT *key_obj) 2757 { 2758 TSS_HKEY hKey; 2759 TSS_RESULT result; 2760 CK_RV rc; 2761 BYTE *modulus; 2762 UINT32 modLen; 2763 RSAbytekey rsa = { 0 }; 2764 uchar_t exp[] = { 0x01, 0x00, 0x01 }; 2765 CK_BYTE plain_data[MAX_RSA_KEYLENGTH]; 2766 size_t data_len; 2767 2768 if ((rc = token_rsa_load_key(hContext, key_obj, &hKey))) { 2769 return (rc); 2770 } 2771 2772 if ((result = Tspi_GetAttribData(hKey, TSS_TSPATTRIB_RSAKEY_INFO, 2773 TSS_TSPATTRIB_KEYINFO_RSA_MODULUS, &modLen, &modulus))) { 2774 stlogit("Tspi_GetAttribData: 0x%0x - %s", 2775 result, Trspi_Error_String(result)); 2776 return (CKR_FUNCTION_FAILED); 2777 } 2778 2779 if (ulSignatureLen != modLen) { 2780 rc = CKR_SIGNATURE_LEN_RANGE; 2781 goto end; 2782 } 2783 2784 rsa.modulus = modulus; 2785 rsa.modulus_bits = CRYPTO_BYTES2BITS(modLen); 2786 rsa.pubexpo = exp; 2787 rsa.pubexpo_bytes = sizeof (exp); 2788 2789 if ((rc = rsa_encrypt(&rsa, pSignature, modLen, plain_data)) != CKR_OK) 2790 goto end; 2791 2792 data_len = modLen; 2793 if ((rc = pkcs1_decode(PKCS1_VERIFY, plain_data, &data_len)) != CKR_OK) 2794 goto end; 2795 2796 (void) memcpy(pData, &plain_data[modLen - data_len], data_len); 2797 *pulDataLen = data_len; 2798 2799 end: 2800 Tspi_Context_FreeMemory(hContext, modulus); 2801 return (rc); 2802 } 2803