security/keys/trusted.c

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