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