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