1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2010 IBM Corporation 4 * Copyright (c) 2019-2021, Linaro Limited 5 * 6 * See Documentation/security/keys/trusted-encrypted.rst 7 */ 8 9 #include <crypto/hash_info.h> 10 #include <linux/init.h> 11 #include <linux/slab.h> 12 #include <linux/parser.h> 13 #include <linux/string.h> 14 #include <linux/err.h> 15 #include <keys/trusted-type.h> 16 #include <linux/key-type.h> 17 #include <linux/crypto.h> 18 #include <crypto/hash.h> 19 #include <crypto/sha1.h> 20 #include <linux/tpm.h> 21 #include <linux/tpm_command.h> 22 23 #include <keys/trusted_tpm.h> 24 25 static const char hmac_alg[] = "hmac(sha1)"; 26 static const char hash_alg[] = "sha1"; 27 static struct tpm_chip *chip; 28 static struct tpm_digest *digests; 29 30 struct sdesc { 31 struct shash_desc shash; 32 char ctx[]; 33 }; 34 35 static struct crypto_shash *hashalg; 36 static struct crypto_shash *hmacalg; 37 38 static struct sdesc *init_sdesc(struct crypto_shash *alg) 39 { 40 struct sdesc *sdesc; 41 int size; 42 43 size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); 44 sdesc = kmalloc(size, GFP_KERNEL); 45 if (!sdesc) 46 return ERR_PTR(-ENOMEM); 47 sdesc->shash.tfm = alg; 48 return sdesc; 49 } 50 51 static int TSS_sha1(const unsigned char *data, unsigned int datalen, 52 unsigned char *digest) 53 { 54 struct sdesc *sdesc; 55 int ret; 56 57 sdesc = init_sdesc(hashalg); 58 if (IS_ERR(sdesc)) { 59 pr_info("can't alloc %s\n", hash_alg); 60 return PTR_ERR(sdesc); 61 } 62 63 ret = crypto_shash_digest(&sdesc->shash, data, datalen, digest); 64 kfree_sensitive(sdesc); 65 return ret; 66 } 67 68 static int TSS_rawhmac(unsigned char *digest, const unsigned char *key, 69 unsigned int keylen, ...) 70 { 71 struct sdesc *sdesc; 72 va_list argp; 73 unsigned int dlen; 74 unsigned char *data; 75 int ret; 76 77 sdesc = init_sdesc(hmacalg); 78 if (IS_ERR(sdesc)) { 79 pr_info("can't alloc %s\n", hmac_alg); 80 return PTR_ERR(sdesc); 81 } 82 83 ret = crypto_shash_setkey(hmacalg, key, keylen); 84 if (ret < 0) 85 goto out; 86 ret = crypto_shash_init(&sdesc->shash); 87 if (ret < 0) 88 goto out; 89 90 va_start(argp, keylen); 91 for (;;) { 92 dlen = va_arg(argp, unsigned int); 93 if (dlen == 0) 94 break; 95 data = va_arg(argp, unsigned char *); 96 if (data == NULL) { 97 ret = -EINVAL; 98 break; 99 } 100 ret = crypto_shash_update(&sdesc->shash, data, dlen); 101 if (ret < 0) 102 break; 103 } 104 va_end(argp); 105 if (!ret) 106 ret = crypto_shash_final(&sdesc->shash, digest); 107 out: 108 kfree_sensitive(sdesc); 109 return ret; 110 } 111 112 /* 113 * calculate authorization info fields to send to TPM 114 */ 115 int TSS_authhmac(unsigned char *digest, const unsigned char *key, 116 unsigned int keylen, unsigned char *h1, 117 unsigned char *h2, unsigned int h3, ...) 118 { 119 unsigned char paramdigest[SHA1_DIGEST_SIZE]; 120 struct sdesc *sdesc; 121 unsigned int dlen; 122 unsigned char *data; 123 unsigned char c; 124 int ret; 125 va_list argp; 126 127 if (!chip) 128 return -ENODEV; 129 130 sdesc = init_sdesc(hashalg); 131 if (IS_ERR(sdesc)) { 132 pr_info("can't alloc %s\n", hash_alg); 133 return PTR_ERR(sdesc); 134 } 135 136 c = !!h3; 137 ret = crypto_shash_init(&sdesc->shash); 138 if (ret < 0) 139 goto out; 140 va_start(argp, h3); 141 for (;;) { 142 dlen = va_arg(argp, unsigned int); 143 if (dlen == 0) 144 break; 145 data = va_arg(argp, unsigned char *); 146 if (!data) { 147 ret = -EINVAL; 148 break; 149 } 150 ret = crypto_shash_update(&sdesc->shash, data, dlen); 151 if (ret < 0) 152 break; 153 } 154 va_end(argp); 155 if (!ret) 156 ret = crypto_shash_final(&sdesc->shash, paramdigest); 157 if (!ret) 158 ret = TSS_rawhmac(digest, key, keylen, SHA1_DIGEST_SIZE, 159 paramdigest, TPM_NONCE_SIZE, h1, 160 TPM_NONCE_SIZE, h2, 1, &c, 0, 0); 161 out: 162 kfree_sensitive(sdesc); 163 return ret; 164 } 165 EXPORT_SYMBOL_GPL(TSS_authhmac); 166 167 /* 168 * verify the AUTH1_COMMAND (Seal) result from TPM 169 */ 170 int TSS_checkhmac1(unsigned char *buffer, 171 const uint32_t command, 172 const unsigned char *ononce, 173 const unsigned char *key, 174 unsigned int keylen, ...) 175 { 176 uint32_t bufsize; 177 uint16_t tag; 178 uint32_t ordinal; 179 uint32_t result; 180 unsigned char *enonce; 181 unsigned char *continueflag; 182 unsigned char *authdata; 183 unsigned char testhmac[SHA1_DIGEST_SIZE]; 184 unsigned char paramdigest[SHA1_DIGEST_SIZE]; 185 struct sdesc *sdesc; 186 unsigned int dlen; 187 unsigned int dpos; 188 va_list argp; 189 int ret; 190 191 if (!chip) 192 return -ENODEV; 193 194 bufsize = LOAD32(buffer, TPM_SIZE_OFFSET); 195 tag = LOAD16(buffer, 0); 196 ordinal = command; 197 result = LOAD32N(buffer, TPM_RETURN_OFFSET); 198 if (tag == TPM_TAG_RSP_COMMAND) 199 return 0; 200 if (tag != TPM_TAG_RSP_AUTH1_COMMAND) 201 return -EINVAL; 202 authdata = buffer + bufsize - SHA1_DIGEST_SIZE; 203 continueflag = authdata - 1; 204 enonce = continueflag - TPM_NONCE_SIZE; 205 206 sdesc = init_sdesc(hashalg); 207 if (IS_ERR(sdesc)) { 208 pr_info("can't alloc %s\n", hash_alg); 209 return PTR_ERR(sdesc); 210 } 211 ret = crypto_shash_init(&sdesc->shash); 212 if (ret < 0) 213 goto out; 214 ret = crypto_shash_update(&sdesc->shash, (const u8 *)&result, 215 sizeof result); 216 if (ret < 0) 217 goto out; 218 ret = crypto_shash_update(&sdesc->shash, (const u8 *)&ordinal, 219 sizeof ordinal); 220 if (ret < 0) 221 goto out; 222 va_start(argp, keylen); 223 for (;;) { 224 dlen = va_arg(argp, unsigned int); 225 if (dlen == 0) 226 break; 227 dpos = va_arg(argp, unsigned int); 228 ret = crypto_shash_update(&sdesc->shash, buffer + dpos, dlen); 229 if (ret < 0) 230 break; 231 } 232 va_end(argp); 233 if (!ret) 234 ret = crypto_shash_final(&sdesc->shash, paramdigest); 235 if (ret < 0) 236 goto out; 237 238 ret = TSS_rawhmac(testhmac, key, keylen, SHA1_DIGEST_SIZE, paramdigest, 239 TPM_NONCE_SIZE, enonce, TPM_NONCE_SIZE, ononce, 240 1, continueflag, 0, 0); 241 if (ret < 0) 242 goto out; 243 244 if (memcmp(testhmac, authdata, SHA1_DIGEST_SIZE)) 245 ret = -EINVAL; 246 out: 247 kfree_sensitive(sdesc); 248 return ret; 249 } 250 EXPORT_SYMBOL_GPL(TSS_checkhmac1); 251 252 /* 253 * verify the AUTH2_COMMAND (unseal) result from TPM 254 */ 255 static int TSS_checkhmac2(unsigned char *buffer, 256 const uint32_t command, 257 const unsigned char *ononce, 258 const unsigned char *key1, 259 unsigned int keylen1, 260 const unsigned char *key2, 261 unsigned int keylen2, ...) 262 { 263 uint32_t bufsize; 264 uint16_t tag; 265 uint32_t ordinal; 266 uint32_t result; 267 unsigned char *enonce1; 268 unsigned char *continueflag1; 269 unsigned char *authdata1; 270 unsigned char *enonce2; 271 unsigned char *continueflag2; 272 unsigned char *authdata2; 273 unsigned char testhmac1[SHA1_DIGEST_SIZE]; 274 unsigned char testhmac2[SHA1_DIGEST_SIZE]; 275 unsigned char paramdigest[SHA1_DIGEST_SIZE]; 276 struct sdesc *sdesc; 277 unsigned int dlen; 278 unsigned int dpos; 279 va_list argp; 280 int ret; 281 282 bufsize = LOAD32(buffer, TPM_SIZE_OFFSET); 283 tag = LOAD16(buffer, 0); 284 ordinal = command; 285 result = LOAD32N(buffer, TPM_RETURN_OFFSET); 286 287 if (tag == TPM_TAG_RSP_COMMAND) 288 return 0; 289 if (tag != TPM_TAG_RSP_AUTH2_COMMAND) 290 return -EINVAL; 291 authdata1 = buffer + bufsize - (SHA1_DIGEST_SIZE + 1 292 + SHA1_DIGEST_SIZE + SHA1_DIGEST_SIZE); 293 authdata2 = buffer + bufsize - (SHA1_DIGEST_SIZE); 294 continueflag1 = authdata1 - 1; 295 continueflag2 = authdata2 - 1; 296 enonce1 = continueflag1 - TPM_NONCE_SIZE; 297 enonce2 = continueflag2 - TPM_NONCE_SIZE; 298 299 sdesc = init_sdesc(hashalg); 300 if (IS_ERR(sdesc)) { 301 pr_info("can't alloc %s\n", hash_alg); 302 return PTR_ERR(sdesc); 303 } 304 ret = crypto_shash_init(&sdesc->shash); 305 if (ret < 0) 306 goto out; 307 ret = crypto_shash_update(&sdesc->shash, (const u8 *)&result, 308 sizeof result); 309 if (ret < 0) 310 goto out; 311 ret = crypto_shash_update(&sdesc->shash, (const u8 *)&ordinal, 312 sizeof ordinal); 313 if (ret < 0) 314 goto out; 315 316 va_start(argp, keylen2); 317 for (;;) { 318 dlen = va_arg(argp, unsigned int); 319 if (dlen == 0) 320 break; 321 dpos = va_arg(argp, unsigned int); 322 ret = crypto_shash_update(&sdesc->shash, buffer + dpos, dlen); 323 if (ret < 0) 324 break; 325 } 326 va_end(argp); 327 if (!ret) 328 ret = crypto_shash_final(&sdesc->shash, paramdigest); 329 if (ret < 0) 330 goto out; 331 332 ret = TSS_rawhmac(testhmac1, key1, keylen1, SHA1_DIGEST_SIZE, 333 paramdigest, TPM_NONCE_SIZE, enonce1, 334 TPM_NONCE_SIZE, ononce, 1, continueflag1, 0, 0); 335 if (ret < 0) 336 goto out; 337 if (memcmp(testhmac1, authdata1, SHA1_DIGEST_SIZE)) { 338 ret = -EINVAL; 339 goto out; 340 } 341 ret = TSS_rawhmac(testhmac2, key2, keylen2, SHA1_DIGEST_SIZE, 342 paramdigest, TPM_NONCE_SIZE, enonce2, 343 TPM_NONCE_SIZE, ononce, 1, continueflag2, 0, 0); 344 if (ret < 0) 345 goto out; 346 if (memcmp(testhmac2, authdata2, SHA1_DIGEST_SIZE)) 347 ret = -EINVAL; 348 out: 349 kfree_sensitive(sdesc); 350 return ret; 351 } 352 353 /* 354 * For key specific tpm requests, we will generate and send our 355 * own TPM command packets using the drivers send function. 356 */ 357 int trusted_tpm_send(unsigned char *cmd, size_t buflen) 358 { 359 int rc; 360 361 if (!chip) 362 return -ENODEV; 363 364 dump_tpm_buf(cmd); 365 rc = tpm_send(chip, cmd, buflen); 366 dump_tpm_buf(cmd); 367 if (rc > 0) 368 /* Can't return positive return codes values to keyctl */ 369 rc = -EPERM; 370 return rc; 371 } 372 EXPORT_SYMBOL_GPL(trusted_tpm_send); 373 374 /* 375 * Lock a trusted key, by extending a selected PCR. 376 * 377 * Prevents a trusted key that is sealed to PCRs from being accessed. 378 * This uses the tpm driver's extend function. 379 */ 380 static int pcrlock(const int pcrnum) 381 { 382 if (!capable(CAP_SYS_ADMIN)) 383 return -EPERM; 384 385 return tpm_pcr_extend(chip, pcrnum, digests) ? -EINVAL : 0; 386 } 387 388 /* 389 * Create an object specific authorisation protocol (OSAP) session 390 */ 391 static int osap(struct tpm_buf *tb, struct osapsess *s, 392 const unsigned char *key, uint16_t type, uint32_t handle) 393 { 394 unsigned char enonce[TPM_NONCE_SIZE]; 395 unsigned char ononce[TPM_NONCE_SIZE]; 396 int ret; 397 398 ret = tpm_get_random(chip, ononce, TPM_NONCE_SIZE); 399 if (ret < 0) 400 return ret; 401 402 if (ret != TPM_NONCE_SIZE) 403 return -EIO; 404 405 tpm_buf_reset(tb, TPM_TAG_RQU_COMMAND, TPM_ORD_OSAP); 406 tpm_buf_append_u16(tb, type); 407 tpm_buf_append_u32(tb, handle); 408 tpm_buf_append(tb, ononce, TPM_NONCE_SIZE); 409 410 ret = trusted_tpm_send(tb->data, MAX_BUF_SIZE); 411 if (ret < 0) 412 return ret; 413 414 s->handle = LOAD32(tb->data, TPM_DATA_OFFSET); 415 memcpy(s->enonce, &(tb->data[TPM_DATA_OFFSET + sizeof(uint32_t)]), 416 TPM_NONCE_SIZE); 417 memcpy(enonce, &(tb->data[TPM_DATA_OFFSET + sizeof(uint32_t) + 418 TPM_NONCE_SIZE]), TPM_NONCE_SIZE); 419 return TSS_rawhmac(s->secret, key, SHA1_DIGEST_SIZE, TPM_NONCE_SIZE, 420 enonce, TPM_NONCE_SIZE, ononce, 0, 0); 421 } 422 423 /* 424 * Create an object independent authorisation protocol (oiap) session 425 */ 426 int oiap(struct tpm_buf *tb, uint32_t *handle, unsigned char *nonce) 427 { 428 int ret; 429 430 if (!chip) 431 return -ENODEV; 432 433 tpm_buf_reset(tb, TPM_TAG_RQU_COMMAND, TPM_ORD_OIAP); 434 ret = trusted_tpm_send(tb->data, MAX_BUF_SIZE); 435 if (ret < 0) 436 return ret; 437 438 *handle = LOAD32(tb->data, TPM_DATA_OFFSET); 439 memcpy(nonce, &tb->data[TPM_DATA_OFFSET + sizeof(uint32_t)], 440 TPM_NONCE_SIZE); 441 return 0; 442 } 443 EXPORT_SYMBOL_GPL(oiap); 444 445 struct tpm_digests { 446 unsigned char encauth[SHA1_DIGEST_SIZE]; 447 unsigned char pubauth[SHA1_DIGEST_SIZE]; 448 unsigned char xorwork[SHA1_DIGEST_SIZE * 2]; 449 unsigned char xorhash[SHA1_DIGEST_SIZE]; 450 unsigned char nonceodd[TPM_NONCE_SIZE]; 451 }; 452 453 /* 454 * Have the TPM seal(encrypt) the trusted key, possibly based on 455 * Platform Configuration Registers (PCRs). AUTH1 for sealing key. 456 */ 457 static int tpm_seal(struct tpm_buf *tb, uint16_t keytype, 458 uint32_t keyhandle, const unsigned char *keyauth, 459 const unsigned char *data, uint32_t datalen, 460 unsigned char *blob, uint32_t *bloblen, 461 const unsigned char *blobauth, 462 const unsigned char *pcrinfo, uint32_t pcrinfosize) 463 { 464 struct osapsess sess; 465 struct tpm_digests *td; 466 unsigned char cont; 467 uint32_t ordinal; 468 uint32_t pcrsize; 469 uint32_t datsize; 470 int sealinfosize; 471 int encdatasize; 472 int storedsize; 473 int ret; 474 int i; 475 476 /* alloc some work space for all the hashes */ 477 td = kmalloc(sizeof *td, GFP_KERNEL); 478 if (!td) 479 return -ENOMEM; 480 481 /* get session for sealing key */ 482 ret = osap(tb, &sess, keyauth, keytype, keyhandle); 483 if (ret < 0) 484 goto out; 485 dump_sess(&sess); 486 487 /* calculate encrypted authorization value */ 488 memcpy(td->xorwork, sess.secret, SHA1_DIGEST_SIZE); 489 memcpy(td->xorwork + SHA1_DIGEST_SIZE, sess.enonce, SHA1_DIGEST_SIZE); 490 ret = TSS_sha1(td->xorwork, SHA1_DIGEST_SIZE * 2, td->xorhash); 491 if (ret < 0) 492 goto out; 493 494 ret = tpm_get_random(chip, td->nonceodd, TPM_NONCE_SIZE); 495 if (ret < 0) 496 goto out; 497 498 if (ret != TPM_NONCE_SIZE) { 499 ret = -EIO; 500 goto out; 501 } 502 503 ordinal = htonl(TPM_ORD_SEAL); 504 datsize = htonl(datalen); 505 pcrsize = htonl(pcrinfosize); 506 cont = 0; 507 508 /* encrypt data authorization key */ 509 for (i = 0; i < SHA1_DIGEST_SIZE; ++i) 510 td->encauth[i] = td->xorhash[i] ^ blobauth[i]; 511 512 /* calculate authorization HMAC value */ 513 if (pcrinfosize == 0) { 514 /* no pcr info specified */ 515 ret = TSS_authhmac(td->pubauth, sess.secret, SHA1_DIGEST_SIZE, 516 sess.enonce, td->nonceodd, cont, 517 sizeof(uint32_t), &ordinal, SHA1_DIGEST_SIZE, 518 td->encauth, sizeof(uint32_t), &pcrsize, 519 sizeof(uint32_t), &datsize, datalen, data, 0, 520 0); 521 } else { 522 /* pcr info specified */ 523 ret = TSS_authhmac(td->pubauth, sess.secret, SHA1_DIGEST_SIZE, 524 sess.enonce, td->nonceodd, cont, 525 sizeof(uint32_t), &ordinal, SHA1_DIGEST_SIZE, 526 td->encauth, sizeof(uint32_t), &pcrsize, 527 pcrinfosize, pcrinfo, sizeof(uint32_t), 528 &datsize, datalen, data, 0, 0); 529 } 530 if (ret < 0) 531 goto out; 532 533 /* build and send the TPM request packet */ 534 tpm_buf_reset(tb, TPM_TAG_RQU_AUTH1_COMMAND, TPM_ORD_SEAL); 535 tpm_buf_append_u32(tb, keyhandle); 536 tpm_buf_append(tb, td->encauth, SHA1_DIGEST_SIZE); 537 tpm_buf_append_u32(tb, pcrinfosize); 538 tpm_buf_append(tb, pcrinfo, pcrinfosize); 539 tpm_buf_append_u32(tb, datalen); 540 tpm_buf_append(tb, data, datalen); 541 tpm_buf_append_u32(tb, sess.handle); 542 tpm_buf_append(tb, td->nonceodd, TPM_NONCE_SIZE); 543 tpm_buf_append_u8(tb, cont); 544 tpm_buf_append(tb, td->pubauth, SHA1_DIGEST_SIZE); 545 546 ret = trusted_tpm_send(tb->data, MAX_BUF_SIZE); 547 if (ret < 0) 548 goto out; 549 550 /* calculate the size of the returned Blob */ 551 sealinfosize = LOAD32(tb->data, TPM_DATA_OFFSET + sizeof(uint32_t)); 552 encdatasize = LOAD32(tb->data, TPM_DATA_OFFSET + sizeof(uint32_t) + 553 sizeof(uint32_t) + sealinfosize); 554 storedsize = sizeof(uint32_t) + sizeof(uint32_t) + sealinfosize + 555 sizeof(uint32_t) + encdatasize; 556 557 /* check the HMAC in the response */ 558 ret = TSS_checkhmac1(tb->data, ordinal, td->nonceodd, sess.secret, 559 SHA1_DIGEST_SIZE, storedsize, TPM_DATA_OFFSET, 0, 560 0); 561 562 /* copy the returned blob to caller */ 563 if (!ret) { 564 memcpy(blob, tb->data + TPM_DATA_OFFSET, storedsize); 565 *bloblen = storedsize; 566 } 567 out: 568 kfree_sensitive(td); 569 return ret; 570 } 571 572 /* 573 * use the AUTH2_COMMAND form of unseal, to authorize both key and blob 574 */ 575 static int tpm_unseal(struct tpm_buf *tb, 576 uint32_t keyhandle, const unsigned char *keyauth, 577 const unsigned char *blob, int bloblen, 578 const unsigned char *blobauth, 579 unsigned char *data, unsigned int *datalen) 580 { 581 unsigned char nonceodd[TPM_NONCE_SIZE]; 582 unsigned char enonce1[TPM_NONCE_SIZE]; 583 unsigned char enonce2[TPM_NONCE_SIZE]; 584 unsigned char authdata1[SHA1_DIGEST_SIZE]; 585 unsigned char authdata2[SHA1_DIGEST_SIZE]; 586 uint32_t authhandle1 = 0; 587 uint32_t authhandle2 = 0; 588 unsigned char cont = 0; 589 uint32_t ordinal; 590 int ret; 591 592 /* sessions for unsealing key and data */ 593 ret = oiap(tb, &authhandle1, enonce1); 594 if (ret < 0) { 595 pr_info("oiap failed (%d)\n", ret); 596 return ret; 597 } 598 ret = oiap(tb, &authhandle2, enonce2); 599 if (ret < 0) { 600 pr_info("oiap failed (%d)\n", ret); 601 return ret; 602 } 603 604 ordinal = htonl(TPM_ORD_UNSEAL); 605 ret = tpm_get_random(chip, nonceodd, TPM_NONCE_SIZE); 606 if (ret < 0) 607 return ret; 608 609 if (ret != TPM_NONCE_SIZE) { 610 pr_info("tpm_get_random failed (%d)\n", ret); 611 return -EIO; 612 } 613 ret = TSS_authhmac(authdata1, keyauth, TPM_NONCE_SIZE, 614 enonce1, nonceodd, cont, sizeof(uint32_t), 615 &ordinal, bloblen, blob, 0, 0); 616 if (ret < 0) 617 return ret; 618 ret = TSS_authhmac(authdata2, blobauth, TPM_NONCE_SIZE, 619 enonce2, nonceodd, cont, sizeof(uint32_t), 620 &ordinal, bloblen, blob, 0, 0); 621 if (ret < 0) 622 return ret; 623 624 /* build and send TPM request packet */ 625 tpm_buf_reset(tb, TPM_TAG_RQU_AUTH2_COMMAND, TPM_ORD_UNSEAL); 626 tpm_buf_append_u32(tb, keyhandle); 627 tpm_buf_append(tb, blob, bloblen); 628 tpm_buf_append_u32(tb, authhandle1); 629 tpm_buf_append(tb, nonceodd, TPM_NONCE_SIZE); 630 tpm_buf_append_u8(tb, cont); 631 tpm_buf_append(tb, authdata1, SHA1_DIGEST_SIZE); 632 tpm_buf_append_u32(tb, authhandle2); 633 tpm_buf_append(tb, nonceodd, TPM_NONCE_SIZE); 634 tpm_buf_append_u8(tb, cont); 635 tpm_buf_append(tb, authdata2, SHA1_DIGEST_SIZE); 636 637 ret = trusted_tpm_send(tb->data, MAX_BUF_SIZE); 638 if (ret < 0) { 639 pr_info("authhmac failed (%d)\n", ret); 640 return ret; 641 } 642 643 *datalen = LOAD32(tb->data, TPM_DATA_OFFSET); 644 ret = TSS_checkhmac2(tb->data, ordinal, nonceodd, 645 keyauth, SHA1_DIGEST_SIZE, 646 blobauth, SHA1_DIGEST_SIZE, 647 sizeof(uint32_t), TPM_DATA_OFFSET, 648 *datalen, TPM_DATA_OFFSET + sizeof(uint32_t), 0, 649 0); 650 if (ret < 0) { 651 pr_info("TSS_checkhmac2 failed (%d)\n", ret); 652 return ret; 653 } 654 memcpy(data, tb->data + TPM_DATA_OFFSET + sizeof(uint32_t), *datalen); 655 return 0; 656 } 657 658 /* 659 * Have the TPM seal(encrypt) the symmetric key 660 */ 661 static int key_seal(struct trusted_key_payload *p, 662 struct trusted_key_options *o) 663 { 664 struct tpm_buf tb; 665 int ret; 666 667 ret = tpm_buf_init(&tb, 0, 0); 668 if (ret) 669 return ret; 670 671 /* include migratable flag at end of sealed key */ 672 p->key[p->key_len] = p->migratable; 673 674 ret = tpm_seal(&tb, o->keytype, o->keyhandle, o->keyauth, 675 p->key, p->key_len + 1, p->blob, &p->blob_len, 676 o->blobauth, o->pcrinfo, o->pcrinfo_len); 677 if (ret < 0) 678 pr_info("srkseal failed (%d)\n", ret); 679 680 tpm_buf_destroy(&tb); 681 return ret; 682 } 683 684 /* 685 * Have the TPM unseal(decrypt) the symmetric key 686 */ 687 static int key_unseal(struct trusted_key_payload *p, 688 struct trusted_key_options *o) 689 { 690 struct tpm_buf tb; 691 int ret; 692 693 ret = tpm_buf_init(&tb, 0, 0); 694 if (ret) 695 return ret; 696 697 ret = tpm_unseal(&tb, o->keyhandle, o->keyauth, p->blob, p->blob_len, 698 o->blobauth, p->key, &p->key_len); 699 if (ret < 0) 700 pr_info("srkunseal failed (%d)\n", ret); 701 else 702 /* pull migratable flag out of sealed key */ 703 p->migratable = p->key[--p->key_len]; 704 705 tpm_buf_destroy(&tb); 706 return ret; 707 } 708 709 enum { 710 Opt_err, 711 Opt_keyhandle, Opt_keyauth, Opt_blobauth, 712 Opt_pcrinfo, Opt_pcrlock, Opt_migratable, 713 Opt_hash, 714 Opt_policydigest, 715 Opt_policyhandle, 716 }; 717 718 static const match_table_t key_tokens = { 719 {Opt_keyhandle, "keyhandle=%s"}, 720 {Opt_keyauth, "keyauth=%s"}, 721 {Opt_blobauth, "blobauth=%s"}, 722 {Opt_pcrinfo, "pcrinfo=%s"}, 723 {Opt_pcrlock, "pcrlock=%s"}, 724 {Opt_migratable, "migratable=%s"}, 725 {Opt_hash, "hash=%s"}, 726 {Opt_policydigest, "policydigest=%s"}, 727 {Opt_policyhandle, "policyhandle=%s"}, 728 {Opt_err, NULL} 729 }; 730 731 /* can have zero or more token= options */ 732 static int getoptions(char *c, struct trusted_key_payload *pay, 733 struct trusted_key_options *opt) 734 { 735 substring_t args[MAX_OPT_ARGS]; 736 char *p = c; 737 int token; 738 int res; 739 unsigned long handle; 740 unsigned long lock; 741 unsigned long token_mask = 0; 742 unsigned int digest_len; 743 int i; 744 int tpm2; 745 746 tpm2 = tpm_is_tpm2(chip); 747 if (tpm2 < 0) 748 return tpm2; 749 750 opt->hash = tpm2 ? HASH_ALGO_SHA256 : HASH_ALGO_SHA1; 751 752 if (!c) 753 return 0; 754 755 while ((p = strsep(&c, " \t"))) { 756 if (*p == '\0' || *p == ' ' || *p == '\t') 757 continue; 758 token = match_token(p, key_tokens, args); 759 if (test_and_set_bit(token, &token_mask)) 760 return -EINVAL; 761 762 switch (token) { 763 case Opt_pcrinfo: 764 opt->pcrinfo_len = strlen(args[0].from) / 2; 765 if (opt->pcrinfo_len > MAX_PCRINFO_SIZE) 766 return -EINVAL; 767 res = hex2bin(opt->pcrinfo, args[0].from, 768 opt->pcrinfo_len); 769 if (res < 0) 770 return -EINVAL; 771 break; 772 case Opt_keyhandle: 773 res = kstrtoul(args[0].from, 16, &handle); 774 if (res < 0) 775 return -EINVAL; 776 opt->keytype = SEAL_keytype; 777 opt->keyhandle = handle; 778 break; 779 case Opt_keyauth: 780 if (strlen(args[0].from) != 2 * SHA1_DIGEST_SIZE) 781 return -EINVAL; 782 res = hex2bin(opt->keyauth, args[0].from, 783 SHA1_DIGEST_SIZE); 784 if (res < 0) 785 return -EINVAL; 786 break; 787 case Opt_blobauth: 788 /* 789 * TPM 1.2 authorizations are sha1 hashes passed in as 790 * hex strings. TPM 2.0 authorizations are simple 791 * passwords (although it can take a hash as well) 792 */ 793 opt->blobauth_len = strlen(args[0].from); 794 795 if (opt->blobauth_len == 2 * TPM_DIGEST_SIZE) { 796 res = hex2bin(opt->blobauth, args[0].from, 797 TPM_DIGEST_SIZE); 798 if (res < 0) 799 return -EINVAL; 800 801 opt->blobauth_len = TPM_DIGEST_SIZE; 802 break; 803 } 804 805 if (tpm2 && opt->blobauth_len <= sizeof(opt->blobauth)) { 806 memcpy(opt->blobauth, args[0].from, 807 opt->blobauth_len); 808 break; 809 } 810 811 return -EINVAL; 812 813 break; 814 815 case Opt_migratable: 816 if (*args[0].from == '0') 817 pay->migratable = 0; 818 else if (*args[0].from != '1') 819 return -EINVAL; 820 break; 821 case Opt_pcrlock: 822 res = kstrtoul(args[0].from, 10, &lock); 823 if (res < 0) 824 return -EINVAL; 825 opt->pcrlock = lock; 826 break; 827 case Opt_hash: 828 if (test_bit(Opt_policydigest, &token_mask)) 829 return -EINVAL; 830 for (i = 0; i < HASH_ALGO__LAST; i++) { 831 if (!strcmp(args[0].from, hash_algo_name[i])) { 832 opt->hash = i; 833 break; 834 } 835 } 836 if (i == HASH_ALGO__LAST) 837 return -EINVAL; 838 if (!tpm2 && i != HASH_ALGO_SHA1) { 839 pr_info("TPM 1.x only supports SHA-1.\n"); 840 return -EINVAL; 841 } 842 break; 843 case Opt_policydigest: 844 digest_len = hash_digest_size[opt->hash]; 845 if (!tpm2 || strlen(args[0].from) != (2 * digest_len)) 846 return -EINVAL; 847 res = hex2bin(opt->policydigest, args[0].from, 848 digest_len); 849 if (res < 0) 850 return -EINVAL; 851 opt->policydigest_len = digest_len; 852 break; 853 case Opt_policyhandle: 854 if (!tpm2) 855 return -EINVAL; 856 res = kstrtoul(args[0].from, 16, &handle); 857 if (res < 0) 858 return -EINVAL; 859 opt->policyhandle = handle; 860 break; 861 default: 862 return -EINVAL; 863 } 864 } 865 return 0; 866 } 867 868 static struct trusted_key_options *trusted_options_alloc(void) 869 { 870 struct trusted_key_options *options; 871 int tpm2; 872 873 tpm2 = tpm_is_tpm2(chip); 874 if (tpm2 < 0) 875 return NULL; 876 877 options = kzalloc(sizeof *options, GFP_KERNEL); 878 if (options) { 879 /* set any non-zero defaults */ 880 options->keytype = SRK_keytype; 881 882 if (!tpm2) 883 options->keyhandle = SRKHANDLE; 884 } 885 return options; 886 } 887 888 static int trusted_tpm_seal(struct trusted_key_payload *p, char *datablob) 889 { 890 struct trusted_key_options *options = NULL; 891 int ret = 0; 892 int tpm2; 893 894 tpm2 = tpm_is_tpm2(chip); 895 if (tpm2 < 0) 896 return tpm2; 897 898 options = trusted_options_alloc(); 899 if (!options) 900 return -ENOMEM; 901 902 ret = getoptions(datablob, p, options); 903 if (ret < 0) 904 goto out; 905 dump_options(options); 906 907 if (!options->keyhandle && !tpm2) { 908 ret = -EINVAL; 909 goto out; 910 } 911 912 if (tpm2) 913 ret = tpm2_seal_trusted(chip, p, options); 914 else 915 ret = key_seal(p, options); 916 if (ret < 0) { 917 pr_info("key_seal failed (%d)\n", ret); 918 goto out; 919 } 920 921 if (options->pcrlock) { 922 ret = pcrlock(options->pcrlock); 923 if (ret < 0) { 924 pr_info("pcrlock failed (%d)\n", ret); 925 goto out; 926 } 927 } 928 out: 929 kfree_sensitive(options); 930 return ret; 931 } 932 933 static int trusted_tpm_unseal(struct trusted_key_payload *p, char *datablob) 934 { 935 struct trusted_key_options *options = NULL; 936 int ret = 0; 937 int tpm2; 938 939 tpm2 = tpm_is_tpm2(chip); 940 if (tpm2 < 0) 941 return tpm2; 942 943 options = trusted_options_alloc(); 944 if (!options) 945 return -ENOMEM; 946 947 ret = getoptions(datablob, p, options); 948 if (ret < 0) 949 goto out; 950 dump_options(options); 951 952 if (!options->keyhandle && !tpm2) { 953 ret = -EINVAL; 954 goto out; 955 } 956 957 if (tpm2) 958 ret = tpm2_unseal_trusted(chip, p, options); 959 else 960 ret = key_unseal(p, options); 961 if (ret < 0) 962 pr_info("key_unseal failed (%d)\n", ret); 963 964 if (options->pcrlock) { 965 ret = pcrlock(options->pcrlock); 966 if (ret < 0) { 967 pr_info("pcrlock failed (%d)\n", ret); 968 goto out; 969 } 970 } 971 out: 972 kfree_sensitive(options); 973 return ret; 974 } 975 976 static int trusted_tpm_get_random(unsigned char *key, size_t key_len) 977 { 978 return tpm_get_random(chip, key, key_len); 979 } 980 981 static void trusted_shash_release(void) 982 { 983 if (hashalg) 984 crypto_free_shash(hashalg); 985 if (hmacalg) 986 crypto_free_shash(hmacalg); 987 } 988 989 static int __init trusted_shash_alloc(void) 990 { 991 int ret; 992 993 hmacalg = crypto_alloc_shash(hmac_alg, 0, 0); 994 if (IS_ERR(hmacalg)) { 995 pr_info("could not allocate crypto %s\n", 996 hmac_alg); 997 return PTR_ERR(hmacalg); 998 } 999 1000 hashalg = crypto_alloc_shash(hash_alg, 0, 0); 1001 if (IS_ERR(hashalg)) { 1002 pr_info("could not allocate crypto %s\n", 1003 hash_alg); 1004 ret = PTR_ERR(hashalg); 1005 goto hashalg_fail; 1006 } 1007 1008 return 0; 1009 1010 hashalg_fail: 1011 crypto_free_shash(hmacalg); 1012 return ret; 1013 } 1014 1015 static int __init init_digests(void) 1016 { 1017 int i; 1018 1019 digests = kcalloc(chip->nr_allocated_banks, sizeof(*digests), 1020 GFP_KERNEL); 1021 if (!digests) 1022 return -ENOMEM; 1023 1024 for (i = 0; i < chip->nr_allocated_banks; i++) 1025 digests[i].alg_id = chip->allocated_banks[i].alg_id; 1026 1027 return 0; 1028 } 1029 1030 static int __init trusted_tpm_init(void) 1031 { 1032 int ret; 1033 1034 chip = tpm_default_chip(); 1035 if (!chip) 1036 return -ENODEV; 1037 1038 ret = init_digests(); 1039 if (ret < 0) 1040 goto err_put; 1041 ret = trusted_shash_alloc(); 1042 if (ret < 0) 1043 goto err_free; 1044 ret = register_key_type(&key_type_trusted); 1045 if (ret < 0) 1046 goto err_release; 1047 return 0; 1048 err_release: 1049 trusted_shash_release(); 1050 err_free: 1051 kfree(digests); 1052 err_put: 1053 put_device(&chip->dev); 1054 return ret; 1055 } 1056 1057 static void trusted_tpm_exit(void) 1058 { 1059 if (chip) { 1060 put_device(&chip->dev); 1061 kfree(digests); 1062 trusted_shash_release(); 1063 unregister_key_type(&key_type_trusted); 1064 } 1065 } 1066 1067 struct trusted_key_ops trusted_key_tpm_ops = { 1068 .migratable = 1, /* migratable by default */ 1069 .init = trusted_tpm_init, 1070 .seal = trusted_tpm_seal, 1071 .unseal = trusted_tpm_unseal, 1072 .get_random = trusted_tpm_get_random, 1073 .exit = trusted_tpm_exit, 1074 }; 1075