?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / char / tpm / tpm2-space.c
blob784b8b3cb903f5e098d1eaac235fec69f5a5a4d6
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2016 Intel Corporation
4 *
5 * Authors:
6 * Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
7 *
8 * Maintained by: <tpmdd-devel@lists.sourceforge.net>
9 *
10 * This file contains TPM2 protocol implementations of the commands
11 * used by the kernel internally.
12 */
13
14 #include <linux/gfp.h>
15 #include <asm/unaligned.h>
16 #include "tpm.h"
17
18 enum tpm2_handle_types {
19 TPM2_HT_HMAC_SESSION = 0x02000000,
20 TPM2_HT_POLICY_SESSION = 0x03000000,
21 TPM2_HT_TRANSIENT = 0x80000000,
22 };
23
24 struct tpm2_context {
25 __be64 sequence;
26 __be32 saved_handle;
27 __be32 hierarchy;
28 __be16 blob_size;
29 } __packed;
30
31 static void tpm2_flush_sessions(struct tpm_chip *chip, struct tpm_space *space)
32 {
33 int i;
34
35 for (i = 0; i < ARRAY_SIZE(space->session_tbl); i++) {
36 if (space->session_tbl[i])
37 tpm2_flush_context(chip, space->session_tbl[i]);
38 }
39 }
40
41 int tpm2_init_space(struct tpm_space *space, unsigned int buf_size)
42 {
43 space->context_buf = kzalloc(buf_size, GFP_KERNEL);
44 if (!space->context_buf)
45 return -ENOMEM;
46
47 space->session_buf = kzalloc(buf_size, GFP_KERNEL);
48 if (space->session_buf == NULL) {
49 kfree(space->context_buf);
50 /* Prevent caller getting a dangling pointer. */
51 space->context_buf = NULL;
52 return -ENOMEM;
53 }
54
55 space->buf_size = buf_size;
56 return 0;
57 }
58
59 void tpm2_del_space(struct tpm_chip *chip, struct tpm_space *space)
60 {
61 mutex_lock(&chip->tpm_mutex);
62 if (!tpm_chip_start(chip)) {
63 tpm2_flush_sessions(chip, space);
64 tpm_chip_stop(chip);
65 }
66 mutex_unlock(&chip->tpm_mutex);
67 kfree(space->context_buf);
68 kfree(space->session_buf);
69 }
70
71 static int tpm2_load_context(struct tpm_chip *chip, u8 *buf,
72 unsigned int *offset, u32 *handle)
73 {
74 struct tpm_buf tbuf;
75 struct tpm2_context *ctx;
76 unsigned int body_size;
77 int rc;
78
79 rc = tpm_buf_init(&tbuf, TPM2_ST_NO_SESSIONS, TPM2_CC_CONTEXT_LOAD);
80 if (rc)
81 return rc;
82
83 ctx = (struct tpm2_context *)&buf[*offset];
84 body_size = sizeof(*ctx) + be16_to_cpu(ctx->blob_size);
85 tpm_buf_append(&tbuf, &buf[*offset], body_size);
86
87 rc = tpm_transmit_cmd(chip, &tbuf, 4, NULL);
88 if (rc < 0) {
89 dev_warn(&chip->dev, "%s: failed with a system error %d\n",
90 __func__, rc);
91 tpm_buf_destroy(&tbuf);
92 return -EFAULT;
93 } else if (tpm2_rc_value(rc) == TPM2_RC_HANDLE ||
94 rc == TPM2_RC_REFERENCE_H0) {
95 /*
96 * TPM_RC_HANDLE means that the session context can't
97 * be loaded because of an internal counter mismatch
98 * that makes the TPM think there might have been a
99 * replay. This might happen if the context was saved
100 * and loaded outside the space.
101 *
102 * TPM_RC_REFERENCE_H0 means the session has been
103 * flushed outside the space
104 */
105 *handle = 0;
106 tpm_buf_destroy(&tbuf);
107 return -ENOENT;
108 } else if (rc > 0) {
109 dev_warn(&chip->dev, "%s: failed with a TPM error 0x%04X\n",
110 __func__, rc);
111 tpm_buf_destroy(&tbuf);
112 return -EFAULT;
113 }
114
115 *handle = be32_to_cpup((__be32 *)&tbuf.data[TPM_HEADER_SIZE]);
116 *offset += body_size;
117
118 tpm_buf_destroy(&tbuf);
119 return 0;
120 }
121
122 static int tpm2_save_context(struct tpm_chip *chip, u32 handle, u8 *buf,
123 unsigned int buf_size, unsigned int *offset)
124 {
125 struct tpm_buf tbuf;
126 unsigned int body_size;
127 int rc;
128
129 rc = tpm_buf_init(&tbuf, TPM2_ST_NO_SESSIONS, TPM2_CC_CONTEXT_SAVE);
130 if (rc)
131 return rc;
132
133 tpm_buf_append_u32(&tbuf, handle);
134
135 rc = tpm_transmit_cmd(chip, &tbuf, 0, NULL);
136 if (rc < 0) {
137 dev_warn(&chip->dev, "%s: failed with a system error %d\n",
138 __func__, rc);
139 tpm_buf_destroy(&tbuf);
140 return -EFAULT;
141 } else if (tpm2_rc_value(rc) == TPM2_RC_REFERENCE_H0) {
142 tpm_buf_destroy(&tbuf);
143 return -ENOENT;
144 } else if (rc) {
145 dev_warn(&chip->dev, "%s: failed with a TPM error 0x%04X\n",
146 __func__, rc);
147 tpm_buf_destroy(&tbuf);
148 return -EFAULT;
149 }
150
151 body_size = tpm_buf_length(&tbuf) - TPM_HEADER_SIZE;
152 if ((*offset + body_size) > buf_size) {
153 dev_warn(&chip->dev, "%s: out of backing storage\n", __func__);
154 tpm_buf_destroy(&tbuf);
155 return -ENOMEM;
156 }
157
158 memcpy(&buf[*offset], &tbuf.data[TPM_HEADER_SIZE], body_size);
159 *offset += body_size;
160 tpm_buf_destroy(&tbuf);
161 return 0;
162 }
163
164 void tpm2_flush_space(struct tpm_chip *chip)
165 {
166 struct tpm_space *space = &chip->work_space;
167 int i;
168
169 for (i = 0; i < ARRAY_SIZE(space->context_tbl); i++)
170 if (space->context_tbl[i] && ~space->context_tbl[i])
171 tpm2_flush_context(chip, space->context_tbl[i]);
172
173 tpm2_flush_sessions(chip, space);
174 }
175
176 static int tpm2_load_space(struct tpm_chip *chip)
177 {
178 struct tpm_space *space = &chip->work_space;
179 unsigned int offset;
180 int i;
181 int rc;
182
183 for (i = 0, offset = 0; i < ARRAY_SIZE(space->context_tbl); i++) {
184 if (!space->context_tbl[i])
185 continue;
186
187 /* sanity check, should never happen */
188 if (~space->context_tbl[i]) {
189 dev_err(&chip->dev, "context table is inconsistent");
190 return -EFAULT;
191 }
192
193 rc = tpm2_load_context(chip, space->context_buf, &offset,
194 &space->context_tbl[i]);
195 if (rc)
196 return rc;
197 }
198
199 for (i = 0, offset = 0; i < ARRAY_SIZE(space->session_tbl); i++) {
200 u32 handle;
201
202 if (!space->session_tbl[i])
203 continue;
204
205 rc = tpm2_load_context(chip, space->session_buf,
206 &offset, &handle);
207 if (rc == -ENOENT) {
208 /* load failed, just forget session */
209 space->session_tbl[i] = 0;
210 } else if (rc) {
211 tpm2_flush_space(chip);
212 return rc;
213 }
214 if (handle != space->session_tbl[i]) {
215 dev_warn(&chip->dev, "session restored to wrong handle\n");
216 tpm2_flush_space(chip);
217 return -EFAULT;
218 }
219 }
220
221 return 0;
222 }
223
224 static bool tpm2_map_to_phandle(struct tpm_space *space, void *handle)
225 {
226 u32 vhandle = be32_to_cpup((__be32 *)handle);
227 u32 phandle;
228 int i;
229
230 i = 0xFFFFFF - (vhandle & 0xFFFFFF);
231 if (i >= ARRAY_SIZE(space->context_tbl) || !space->context_tbl[i])
232 return false;
233
234 phandle = space->context_tbl[i];
235 *((__be32 *)handle) = cpu_to_be32(phandle);
236 return true;
237 }
238
239 static int tpm2_map_command(struct tpm_chip *chip, u32 cc, u8 *cmd)
240 {
241 struct tpm_space *space = &chip->work_space;
242 unsigned int nr_handles;
243 u32 attrs;
244 __be32 *handle;
245 int i;
246
247 i = tpm2_find_cc(chip, cc);
248 if (i < 0)
249 return -EINVAL;
250
251 attrs = chip->cc_attrs_tbl[i];
252 nr_handles = (attrs >> TPM2_CC_ATTR_CHANDLES) & GENMASK(2, 0);
253
254 handle = (__be32 *)&cmd[TPM_HEADER_SIZE];
255 for (i = 0; i < nr_handles; i++, handle++) {
256 if ((be32_to_cpu(*handle) & 0xFF000000) == TPM2_HT_TRANSIENT) {
257 if (!tpm2_map_to_phandle(space, handle))
258 return -EINVAL;
259 }
260 }
261
262 return 0;
263 }
264
265 static int tpm_find_and_validate_cc(struct tpm_chip *chip,
266 struct tpm_space *space,
267 const void *cmd, size_t len)
268 {
269 const struct tpm_header *header = (const void *)cmd;
270 int i;
271 u32 cc;
272 u32 attrs;
273 unsigned int nr_handles;
274
275 if (len < TPM_HEADER_SIZE || !chip->nr_commands)
276 return -EINVAL;
277
278 cc = be32_to_cpu(header->ordinal);
279
280 i = tpm2_find_cc(chip, cc);
281 if (i < 0) {
282 dev_dbg(&chip->dev, "0x%04X is an invalid command\n",
283 cc);
284 return -EOPNOTSUPP;
285 }
286
287 attrs = chip->cc_attrs_tbl[i];
288 nr_handles =
289 4 * ((attrs >> TPM2_CC_ATTR_CHANDLES) & GENMASK(2, 0));
290 if (len < TPM_HEADER_SIZE + 4 * nr_handles)
291 goto err_len;
292
293 return cc;
294 err_len:
295 dev_dbg(&chip->dev, "%s: insufficient command length %zu", __func__,
296 len);
297 return -EINVAL;
298 }
299
300 int tpm2_prepare_space(struct tpm_chip *chip, struct tpm_space *space, u8 *cmd,
301 size_t cmdsiz)
302 {
303 int rc;
304 int cc;
305
306 if (!space)
307 return 0;
308
309 cc = tpm_find_and_validate_cc(chip, space, cmd, cmdsiz);
310 if (cc < 0)
311 return cc;
312
313 memcpy(&chip->work_space.context_tbl, &space->context_tbl,
314 sizeof(space->context_tbl));
315 memcpy(&chip->work_space.session_tbl, &space->session_tbl,
316 sizeof(space->session_tbl));
317 memcpy(chip->work_space.context_buf, space->context_buf,
318 space->buf_size);
319 memcpy(chip->work_space.session_buf, space->session_buf,
320 space->buf_size);
321
322 rc = tpm2_load_space(chip);
323 if (rc) {
324 tpm2_flush_space(chip);
325 return rc;
326 }
327
328 rc = tpm2_map_command(chip, cc, cmd);
329 if (rc) {
330 tpm2_flush_space(chip);
331 return rc;
332 }
333
334 chip->last_cc = cc;
335 return 0;
336 }
337
338 static bool tpm2_add_session(struct tpm_chip *chip, u32 handle)
339 {
340 struct tpm_space *space = &chip->work_space;
341 int i;
342
343 for (i = 0; i < ARRAY_SIZE(space->session_tbl); i++)
344 if (space->session_tbl[i] == 0)
345 break;
346
347 if (i == ARRAY_SIZE(space->session_tbl))
348 return false;
349
350 space->session_tbl[i] = handle;
351 return true;
352 }
353
354 static u32 tpm2_map_to_vhandle(struct tpm_space *space, u32 phandle, bool alloc)
355 {
356 int i;
357
358 for (i = 0; i < ARRAY_SIZE(space->context_tbl); i++) {
359 if (alloc) {
360 if (!space->context_tbl[i]) {
361 space->context_tbl[i] = phandle;
362 break;
363 }
364 } else if (space->context_tbl[i] == phandle)
365 break;
366 }
367
368 if (i == ARRAY_SIZE(space->context_tbl))
369 return 0;
370
371 return TPM2_HT_TRANSIENT | (0xFFFFFF - i);
372 }
373
374 static int tpm2_map_response_header(struct tpm_chip *chip, u32 cc, u8 *rsp,
375 size_t len)
376 {
377 struct tpm_space *space = &chip->work_space;
378 struct tpm_header *header = (struct tpm_header *)rsp;
379 u32 phandle;
380 u32 phandle_type;
381 u32 vhandle;
382 u32 attrs;
383 int i;
384
385 if (be32_to_cpu(header->return_code) != TPM2_RC_SUCCESS)
386 return 0;
387
388 i = tpm2_find_cc(chip, cc);
389 /* sanity check, should never happen */
390 if (i < 0)
391 return -EFAULT;
392
393 attrs = chip->cc_attrs_tbl[i];
394 if (!((attrs >> TPM2_CC_ATTR_RHANDLE) & 1))
395 return 0;
396
397 phandle = be32_to_cpup((__be32 *)&rsp[TPM_HEADER_SIZE]);
398 phandle_type = phandle & 0xFF000000;
399
400 switch (phandle_type) {
401 case TPM2_HT_TRANSIENT:
402 vhandle = tpm2_map_to_vhandle(space, phandle, true);
403 if (!vhandle)
404 goto out_no_slots;
405
406 *(__be32 *)&rsp[TPM_HEADER_SIZE] = cpu_to_be32(vhandle);
407 break;
408 case TPM2_HT_HMAC_SESSION:
409 case TPM2_HT_POLICY_SESSION:
410 if (!tpm2_add_session(chip, phandle))
411 goto out_no_slots;
412 break;
413 default:
414 dev_err(&chip->dev, "%s: unknown handle 0x%08X\n",
415 __func__, phandle);
416 break;
417 }
418
419 return 0;
420 out_no_slots:
421 tpm2_flush_context(chip, phandle);
422 dev_warn(&chip->dev, "%s: out of slots for 0x%08X\n", __func__,
423 phandle);
424 return -ENOMEM;
425 }
426
427 struct tpm2_cap_handles {
428 u8 more_data;
429 __be32 capability;
430 __be32 count;
431 __be32 handles[];
432 } __packed;
433
434 static int tpm2_map_response_body(struct tpm_chip *chip, u32 cc, u8 *rsp,
435 size_t len)
436 {
437 struct tpm_space *space = &chip->work_space;
438 struct tpm_header *header = (struct tpm_header *)rsp;
439 struct tpm2_cap_handles *data;
440 u32 phandle;
441 u32 phandle_type;
442 u32 vhandle;
443 int i;
444 int j;
445
446 if (cc != TPM2_CC_GET_CAPABILITY ||
447 be32_to_cpu(header->return_code) != TPM2_RC_SUCCESS) {
448 return 0;
449 }
450
451 if (len < TPM_HEADER_SIZE + 9)
452 return -EFAULT;
453
454 data = (void *)&rsp[TPM_HEADER_SIZE];
455 if (be32_to_cpu(data->capability) != TPM2_CAP_HANDLES)
456 return 0;
457
458 if (len != TPM_HEADER_SIZE + 9 + 4 * be32_to_cpu(data->count))
459 return -EFAULT;
460
461 for (i = 0, j = 0; i < be32_to_cpu(data->count); i++) {
462 phandle = be32_to_cpup((__be32 *)&data->handles[i]);
463 phandle_type = phandle & 0xFF000000;
464
465 switch (phandle_type) {
466 case TPM2_HT_TRANSIENT:
467 vhandle = tpm2_map_to_vhandle(space, phandle, false);
468 if (!vhandle)
469 break;
470
471 data->handles[j] = cpu_to_be32(vhandle);
472 j++;
473 break;
474
475 default:
476 data->handles[j] = cpu_to_be32(phandle);
477 j++;
478 break;
479 }
480
481 }
482
483 header->length = cpu_to_be32(TPM_HEADER_SIZE + 9 + 4 * j);
484 data->count = cpu_to_be32(j);
485 return 0;
486 }
487
488 static int tpm2_save_space(struct tpm_chip *chip)
489 {
490 struct tpm_space *space = &chip->work_space;
491 unsigned int offset;
492 int i;
493 int rc;
494
495 for (i = 0, offset = 0; i < ARRAY_SIZE(space->context_tbl); i++) {
496 if (!(space->context_tbl[i] && ~space->context_tbl[i]))
497 continue;
498
499 rc = tpm2_save_context(chip, space->context_tbl[i],
500 space->context_buf, space->buf_size,
501 &offset);
502 if (rc == -ENOENT) {
503 space->context_tbl[i] = 0;
504 continue;
505 } else if (rc)
506 return rc;
507
508 tpm2_flush_context(chip, space->context_tbl[i]);
509 space->context_tbl[i] = ~0;
510 }
511
512 for (i = 0, offset = 0; i < ARRAY_SIZE(space->session_tbl); i++) {
513 if (!space->session_tbl[i])
514 continue;
515
516 rc = tpm2_save_context(chip, space->session_tbl[i],
517 space->session_buf, space->buf_size,
518 &offset);
519 if (rc == -ENOENT) {
520 /* handle error saving session, just forget it */
521 space->session_tbl[i] = 0;
522 } else if (rc < 0) {
523 tpm2_flush_space(chip);
524 return rc;
525 }
526 }
527
528 return 0;
529 }
530
531 int tpm2_commit_space(struct tpm_chip *chip, struct tpm_space *space,
532 void *buf, size_t *bufsiz)
533 {
534 struct tpm_header *header = buf;
535 int rc;
536
537 if (!space)
538 return 0;
539
540 rc = tpm2_map_response_header(chip, chip->last_cc, buf, *bufsiz);
541 if (rc) {
542 tpm2_flush_space(chip);
543 goto out;
544 }
545
546 rc = tpm2_map_response_body(chip, chip->last_cc, buf, *bufsiz);
547 if (rc) {
548 tpm2_flush_space(chip);
549 goto out;
550 }
551
552 rc = tpm2_save_space(chip);
553 if (rc) {
554 tpm2_flush_space(chip);
555 goto out;
556 }
557
558 *bufsiz = be32_to_cpu(header->length);
559
560 memcpy(&space->context_tbl, &chip->work_space.context_tbl,
561 sizeof(space->context_tbl));
562 memcpy(&space->session_tbl, &chip->work_space.session_tbl,
563 sizeof(space->session_tbl));
564 memcpy(space->context_buf, chip->work_space.context_buf,
565 space->buf_size);
566 memcpy(space->session_buf, chip->work_space.session_buf,
567 space->buf_size);
568
569 return 0;
570 out:
571 dev_err(&chip->dev, "%s: error %d\n", __func__, rc);
572 return rc;
573 }
Linux with added FPC-III support