1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2015 Google, Inc
4 */
5
6 #include <command.h>
7 #include <cpu_func.h>
8 #include <log.h>
9 #include <time.h>
10 #include <tpm-v1.h>
11 #include <linux/printk.h>
12 #include "tpm-user-utils.h"
13 #include <tpm_api.h>
14
15 /* Prints error and returns on failure */
16 #define TPM_CHECK(tpm_command) do { \
17 uint32_t result; \
18 \
19 result = (tpm_command); \
20 if (result != TPM_SUCCESS) { \
21 printf("TEST FAILED: line %d: " #tpm_command ": 0x%x\n", \
22 __LINE__, result); \
23 return result; \
24 } \
25 } while (0)
26
27 #define INDEX0 0xda70
28 #define INDEX1 0xda71
29 #define INDEX2 0xda72
30 #define INDEX3 0xda73
31 #define INDEX_INITIALISED 0xda80
32 #define PHYS_PRESENCE 4
33 #define PRESENCE 8
34
TlclStartupIfNeeded(struct udevice * dev)35 static uint32_t TlclStartupIfNeeded(struct udevice *dev)
36 {
37 uint32_t result = tpm_startup(dev, TPM_ST_CLEAR);
38
39 return result == TPM_INVALID_POSTINIT ? TPM_SUCCESS : result;
40 }
41
test_timer(struct udevice * dev)42 static int test_timer(struct udevice *dev)
43 {
44 printf("get_timer(0) = %lu\n", get_timer(0));
45 return 0;
46 }
47
tpm_get_flags(struct udevice * dev,uint8_t * disable,uint8_t * deactivated,uint8_t * nvlocked)48 static uint32_t tpm_get_flags(struct udevice *dev, uint8_t *disable,
49 uint8_t *deactivated, uint8_t *nvlocked)
50 {
51 struct tpm_permanent_flags pflags;
52 uint32_t result;
53
54 result = tpm1_get_permanent_flags(dev, &pflags);
55 if (result)
56 return result;
57 if (disable)
58 *disable = pflags.disable;
59 if (deactivated)
60 *deactivated = pflags.deactivated;
61 if (nvlocked)
62 *nvlocked = pflags.nv_locked;
63 debug("TPM: Got flags disable=%d, deactivated=%d, nvlocked=%d\n",
64 pflags.disable, pflags.deactivated, pflags.nv_locked);
65
66 return 0;
67 }
68
tpm_nv_write_value_lock(struct udevice * dev,uint32_t index)69 static uint32_t tpm_nv_write_value_lock(struct udevice *dev, uint32_t index)
70 {
71 debug("TPM: Write lock 0x%x\n", index);
72
73 return tpm_nv_write_value(dev, index, NULL, 0);
74 }
75
tpm_is_owned(struct udevice * dev)76 static int tpm_is_owned(struct udevice *dev)
77 {
78 uint8_t response[TPM_PUBEK_SIZE];
79 uint32_t result;
80
81 result = tpm_read_pubek(dev, response, sizeof(response));
82
83 return result != TPM_SUCCESS;
84 }
85
test_early_extend(struct udevice * dev)86 static int test_early_extend(struct udevice *dev)
87 {
88 uint8_t value_in[20];
89 uint8_t value_out[20];
90
91 printf("Testing earlyextend ...");
92 tpm_init(dev);
93 TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR));
94 TPM_CHECK(tpm_continue_self_test(dev));
95 TPM_CHECK(tpm_pcr_extend(dev, 1, value_in, sizeof(value_in), value_out,
96 "test"));
97 printf("done\n");
98 return 0;
99 }
100
test_early_nvram(struct udevice * dev)101 static int test_early_nvram(struct udevice *dev)
102 {
103 uint32_t x;
104
105 printf("Testing earlynvram ...");
106 tpm_init(dev);
107 TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR));
108 TPM_CHECK(tpm_continue_self_test(dev));
109 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
110 TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
111 printf("done\n");
112 return 0;
113 }
114
test_early_nvram2(struct udevice * dev)115 static int test_early_nvram2(struct udevice *dev)
116 {
117 uint32_t x;
118
119 printf("Testing earlynvram2 ...");
120 tpm_init(dev);
121 TPM_CHECK(tpm_startup(dev, TPM_ST_CLEAR));
122 TPM_CHECK(tpm_continue_self_test(dev));
123 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
124 TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
125 printf("done\n");
126 return 0;
127 }
128
test_enable(struct udevice * dev)129 static int test_enable(struct udevice *dev)
130 {
131 uint8_t disable = 0, deactivated = 0;
132
133 printf("Testing enable ...\n");
134 tpm_init(dev);
135 TPM_CHECK(TlclStartupIfNeeded(dev));
136 TPM_CHECK(tpm_self_test_full(dev));
137 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
138 TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
139 printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
140 TPM_CHECK(tpm_physical_enable(dev));
141 TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
142 TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
143 printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
144 if (disable == 1 || deactivated == 1)
145 printf("\tfailed to enable or activate\n");
146 printf("\tdone\n");
147 return 0;
148 }
149
150 #define reboot() do { \
151 printf("\trebooting...\n"); \
152 reset_cpu(); \
153 } while (0)
154
test_fast_enable(struct udevice * dev)155 static int test_fast_enable(struct udevice *dev)
156 {
157 uint8_t disable = 0, deactivated = 0;
158 int i;
159
160 printf("Testing fastenable ...\n");
161 tpm_init(dev);
162 TPM_CHECK(TlclStartupIfNeeded(dev));
163 TPM_CHECK(tpm_self_test_full(dev));
164 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
165 TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
166 printf("\tdisable is %d, deactivated is %d\n", disable, deactivated);
167 for (i = 0; i < 2; i++) {
168 TPM_CHECK(tpm_force_clear(dev));
169 TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
170 printf("\tdisable is %d, deactivated is %d\n", disable,
171 deactivated);
172 assert(disable == 1 && deactivated == 1);
173 TPM_CHECK(tpm_physical_enable(dev));
174 TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
175 TPM_CHECK(tpm_get_flags(dev, &disable, &deactivated, NULL));
176 printf("\tdisable is %d, deactivated is %d\n", disable,
177 deactivated);
178 assert(disable == 0 && deactivated == 0);
179 }
180 printf("\tdone\n");
181 return 0;
182 }
183
test_global_lock(struct udevice * dev)184 static int test_global_lock(struct udevice *dev)
185 {
186 uint32_t zero = 0;
187 uint32_t result;
188 uint32_t x;
189
190 printf("Testing globallock ...\n");
191 tpm_init(dev);
192 TPM_CHECK(TlclStartupIfNeeded(dev));
193 TPM_CHECK(tpm_self_test_full(dev));
194 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
195 TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
196 TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero,
197 sizeof(uint32_t)));
198 TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
199 TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero,
200 sizeof(uint32_t)));
201 TPM_CHECK(tpm_set_global_lock(dev));
202 /* Verifies that write to index0 fails */
203 x = 1;
204 result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x));
205 assert(result == TPM_AREA_LOCKED);
206 TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
207 assert(x == 0);
208 /* Verifies that write to index1 is still possible */
209 x = 2;
210 TPM_CHECK(tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
211 TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
212 assert(x == 2);
213 /* Turns off PP */
214 tpm_tsc_physical_presence(dev, PHYS_PRESENCE);
215 /* Verifies that write to index1 fails */
216 x = 3;
217 result = tpm_nv_write_value(dev, INDEX1, (uint8_t *)&x, sizeof(x));
218 assert(result == TPM_BAD_PRESENCE);
219 TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
220 assert(x == 2);
221 printf("\tdone\n");
222 return 0;
223 }
224
test_lock(struct udevice * dev)225 static int test_lock(struct udevice *dev)
226 {
227 printf("Testing lock ...\n");
228 tpm_init(dev);
229 tpm_startup(dev, TPM_ST_CLEAR);
230 tpm_self_test_full(dev);
231 tpm_tsc_physical_presence(dev, PRESENCE);
232 tpm_nv_write_value_lock(dev, INDEX0);
233 printf("\tLocked 0x%x\n", INDEX0);
234 printf("\tdone\n");
235 return 0;
236 }
237
initialise_spaces(struct udevice * dev)238 static void initialise_spaces(struct udevice *dev)
239 {
240 uint32_t zero = 0;
241 uint32_t perm = TPM_NV_PER_WRITE_STCLEAR | TPM_NV_PER_PPWRITE;
242
243 printf("\tInitialising spaces\n");
244 tpm1_nv_set_locked(dev); /* useful only the first time */
245 tpm1_nv_define_space(dev, INDEX0, perm, 4);
246 tpm_nv_write_value(dev, INDEX0, (uint8_t *)&zero, 4);
247 tpm1_nv_define_space(dev, INDEX1, perm, 4);
248 tpm_nv_write_value(dev, INDEX1, (uint8_t *)&zero, 4);
249 tpm1_nv_define_space(dev, INDEX2, perm, 4);
250 tpm_nv_write_value(dev, INDEX2, (uint8_t *)&zero, 4);
251 tpm1_nv_define_space(dev, INDEX3, perm, 4);
252 tpm_nv_write_value(dev, INDEX3, (uint8_t *)&zero, 4);
253 perm = TPM_NV_PER_READ_STCLEAR | TPM_NV_PER_WRITE_STCLEAR |
254 TPM_NV_PER_PPWRITE;
255 tpm1_nv_define_space(dev, INDEX_INITIALISED, perm, 1);
256 }
257
test_readonly(struct udevice * dev)258 static int test_readonly(struct udevice *dev)
259 {
260 uint8_t c;
261 uint32_t index_0, index_1, index_2, index_3;
262 int read0, read1, read2, read3;
263
264 printf("Testing readonly ...\n");
265 tpm_init(dev);
266 tpm_startup(dev, TPM_ST_CLEAR);
267 tpm_self_test_full(dev);
268 tpm_tsc_physical_presence(dev, PRESENCE);
269 /*
270 * Checks if initialisation has completed by trying to read-lock a
271 * space that's created at the end of initialisation
272 */
273 if (tpm_nv_read_value(dev, INDEX_INITIALISED, &c, 0) == TPM_BADINDEX) {
274 /* The initialisation did not complete */
275 initialise_spaces(dev);
276 }
277
278 /* Checks if spaces are OK or messed up */
279 read0 = tpm_nv_read_value(dev, INDEX0, (uint8_t *)&index_0,
280 sizeof(index_0));
281 read1 = tpm_nv_read_value(dev, INDEX1, (uint8_t *)&index_1,
282 sizeof(index_1));
283 read2 = tpm_nv_read_value(dev, INDEX2, (uint8_t *)&index_2,
284 sizeof(index_2));
285 read3 = tpm_nv_read_value(dev, INDEX3, (uint8_t *)&index_3,
286 sizeof(index_3));
287 if (read0 || read1 || read2 || read3) {
288 printf("Invalid contents\n");
289 return 0;
290 }
291
292 /*
293 * Writes space, and locks it. Then attempts to write again.
294 * I really wish I could use the imperative.
295 */
296 index_0 += 1;
297 if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0,
298 sizeof(index_0)) !=
299 TPM_SUCCESS) {
300 pr_err("\tcould not write index 0\n");
301 }
302 tpm_nv_write_value_lock(dev, INDEX0);
303 if (tpm_nv_write_value(dev, INDEX0, (uint8_t *)&index_0,
304 sizeof(index_0)) ==
305 TPM_SUCCESS)
306 pr_err("\tindex 0 is not locked\n");
307
308 printf("\tdone\n");
309 return 0;
310 }
311
test_redefine_unowned(struct udevice * dev)312 static int test_redefine_unowned(struct udevice *dev)
313 {
314 uint32_t perm;
315 uint32_t result;
316 uint32_t x;
317
318 printf("Testing redefine_unowned ...");
319 tpm_init(dev);
320 TPM_CHECK(TlclStartupIfNeeded(dev));
321 TPM_CHECK(tpm_self_test_full(dev));
322 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
323 assert(!tpm_is_owned(dev));
324
325 /* Ensures spaces exist. */
326 TPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)));
327 TPM_CHECK(tpm_nv_read_value(dev, INDEX1, (uint8_t *)&x, sizeof(x)));
328
329 /* Redefines spaces a couple of times. */
330 perm = TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK;
331 TPM_CHECK(tpm1_nv_define_space(dev, INDEX0, perm,
332 2 * sizeof(uint32_t)));
333 TPM_CHECK(tpm1_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t)));
334 perm = TPM_NV_PER_PPWRITE;
335 TPM_CHECK(tpm1_nv_define_space(dev, INDEX1, perm,
336 2 * sizeof(uint32_t)));
337 TPM_CHECK(tpm1_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t)));
338
339 /* Sets the global lock */
340 tpm_set_global_lock(dev);
341
342 /* Verifies that index0 cannot be redefined */
343 result = tpm1_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t));
344 assert(result == TPM_AREA_LOCKED);
345
346 /* Checks that index1 can */
347 TPM_CHECK(tpm1_nv_define_space(dev, INDEX1, perm,
348 2 * sizeof(uint32_t)));
349 TPM_CHECK(tpm1_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t)));
350
351 /* Turns off PP */
352 tpm_tsc_physical_presence(dev, PHYS_PRESENCE);
353
354 /* Verifies that neither index0 nor index1 can be redefined */
355 result = tpm1_nv_define_space(dev, INDEX0, perm, sizeof(uint32_t));
356 assert(result == TPM_BAD_PRESENCE);
357 result = tpm1_nv_define_space(dev, INDEX1, perm, sizeof(uint32_t));
358 assert(result == TPM_BAD_PRESENCE);
359
360 printf("done\n");
361 return 0;
362 }
363
364 #define PERMPPGL (TPM_NV_PER_PPWRITE | TPM_NV_PER_GLOBALLOCK)
365 #define PERMPP TPM_NV_PER_PPWRITE
366
test_space_perm(struct udevice * dev)367 static int test_space_perm(struct udevice *dev)
368 {
369 uint32_t perm;
370
371 printf("Testing spaceperm ...");
372 tpm_init(dev);
373 TPM_CHECK(TlclStartupIfNeeded(dev));
374 TPM_CHECK(tpm_continue_self_test(dev));
375 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
376 TPM_CHECK(tpm_get_permissions(dev, INDEX0, &perm));
377 assert((perm & PERMPPGL) == PERMPPGL);
378 TPM_CHECK(tpm_get_permissions(dev, INDEX1, &perm));
379 assert((perm & PERMPP) == PERMPP);
380 printf("done\n");
381 return 0;
382 }
383
test_startup(struct udevice * dev)384 static int test_startup(struct udevice *dev)
385 {
386 uint32_t result;
387
388 printf("Testing startup ...\n");
389
390 tpm_init(dev);
391 result = tpm_startup(dev, TPM_ST_CLEAR);
392 if (result != 0 && result != TPM_INVALID_POSTINIT)
393 printf("\ttpm startup failed with 0x%x\n", result);
394 result = tpm_get_flags(dev, NULL, NULL, NULL);
395 if (result != 0)
396 printf("\ttpm getflags failed with 0x%x\n", result);
397 printf("\texecuting SelfTestFull\n");
398 tpm_self_test_full(dev);
399 result = tpm_get_flags(dev, NULL, NULL, NULL);
400 if (result != 0)
401 printf("\ttpm getflags failed with 0x%x\n", result);
402 printf("\tdone\n");
403 return 0;
404 }
405
406 /*
407 * Runs [op] and ensures it returns success and doesn't run longer than
408 * [time_limit] in milliseconds.
409 */
410 #define TTPM_CHECK(op, time_limit) do { \
411 ulong start, time; \
412 uint32_t __result; \
413 \
414 start = get_timer(0); \
415 __result = op; \
416 if (__result != TPM_SUCCESS) { \
417 printf("\t" #op ": error 0x%x\n", __result); \
418 return -1; \
419 } \
420 time = get_timer(start); \
421 printf("\t" #op ": %lu ms\n", time); \
422 if (time > (ulong)time_limit) { \
423 printf("\t" #op " exceeded " #time_limit " ms\n"); \
424 } \
425 } while (0)
426
test_timing(struct udevice * dev)427 static int test_timing(struct udevice *dev)
428 {
429 uint8_t in[20], out[20];
430 uint32_t x;
431
432 printf("Testing timing ...");
433 tpm_init(dev);
434 TTPM_CHECK(TlclStartupIfNeeded(dev), 50);
435 TTPM_CHECK(tpm_continue_self_test(dev), 100);
436 TTPM_CHECK(tpm_self_test_full(dev), 1000);
437 TTPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE), 100);
438 TTPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)),
439 100);
440 TTPM_CHECK(tpm_nv_read_value(dev, INDEX0, (uint8_t *)&x, sizeof(x)),
441 100);
442 TTPM_CHECK(tpm_pcr_extend(dev, 0, in, sizeof(in), out, "test"), 200);
443 TTPM_CHECK(tpm_set_global_lock(dev), 50);
444 TTPM_CHECK(tpm_tsc_physical_presence(dev, PHYS_PRESENCE), 100);
445 printf("done\n");
446 return 0;
447 }
448
449 #define TPM_MAX_NV_WRITES_NOOWNER 64
450
test_write_limit(struct udevice * dev)451 static int test_write_limit(struct udevice *dev)
452 {
453 uint32_t result;
454 int i;
455
456 printf("Testing writelimit ...\n");
457 tpm_init(dev);
458 TPM_CHECK(TlclStartupIfNeeded(dev));
459 TPM_CHECK(tpm_self_test_full(dev));
460 TPM_CHECK(tpm_tsc_physical_presence(dev, PRESENCE));
461 TPM_CHECK(tpm_force_clear(dev));
462 TPM_CHECK(tpm_physical_enable(dev));
463 TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
464
465 for (i = 0; i < TPM_MAX_NV_WRITES_NOOWNER + 2; i++) {
466 printf("\twriting %d\n", i);
467 result = tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i,
468 sizeof(i));
469 switch (result) {
470 case TPM_SUCCESS:
471 break;
472 case TPM_MAXNVWRITES:
473 assert(i >= TPM_MAX_NV_WRITES_NOOWNER);
474 break;
475 default:
476 pr_err("\tunexpected error code %d (0x%x)\n",
477 result, result);
478 }
479 }
480
481 /* Reset write count */
482 TPM_CHECK(tpm_force_clear(dev));
483 TPM_CHECK(tpm_physical_enable(dev));
484 TPM_CHECK(tpm_physical_set_deactivated(dev, 0));
485
486 /* Try writing again. */
487 TPM_CHECK(tpm_nv_write_value(dev, INDEX0, (uint8_t *)&i, sizeof(i)));
488 printf("\tdone\n");
489 return 0;
490 }
491
492 #define VOIDTEST(XFUNC) \
493 int do_test_##XFUNC(struct cmd_tbl *cmd_tbl, int flag, int argc, \
494 char *const argv[]) \
495 { \
496 struct udevice *dev; \
497 int ret; \
498 \
499 ret = get_tpm(&dev); \
500 if (ret) \
501 return ret; \
502 return test_##XFUNC(dev); \
503 }
504
505 #define VOIDENT(XNAME) \
506 U_BOOT_CMD_MKENT(XNAME, 0, 1, do_test_##XNAME, "", ""),
507
508 VOIDTEST(early_extend)
509 VOIDTEST(early_nvram)
510 VOIDTEST(early_nvram2)
511 VOIDTEST(enable)
512 VOIDTEST(fast_enable)
513 VOIDTEST(global_lock)
514 VOIDTEST(lock)
515 VOIDTEST(readonly)
516 VOIDTEST(redefine_unowned)
517 VOIDTEST(space_perm)
518 VOIDTEST(startup)
519 VOIDTEST(timing)
520 VOIDTEST(write_limit)
521 VOIDTEST(timer)
522
523 static struct cmd_tbl cmd_cros_tpm_sub[] = {
524 VOIDENT(early_extend)
525 VOIDENT(early_nvram)
526 VOIDENT(early_nvram2)
527 VOIDENT(enable)
528 VOIDENT(fast_enable)
529 VOIDENT(global_lock)
530 VOIDENT(lock)
531 VOIDENT(readonly)
532 VOIDENT(redefine_unowned)
533 VOIDENT(space_perm)
534 VOIDENT(startup)
535 VOIDENT(timing)
536 VOIDENT(write_limit)
537 VOIDENT(timer)
538 };
539
do_tpmtest(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])540 static int do_tpmtest(struct cmd_tbl *cmdtp, int flag, int argc,
541 char *const argv[])
542 {
543 struct cmd_tbl *c;
544 int i;
545
546 printf("argc = %d, argv = ", argc);
547
548 for (i = 0; i < argc; i++)
549 printf(" %s", argv[i]);
550
551 printf("\n------\n");
552
553 argc--;
554 argv++;
555 c = find_cmd_tbl(argv[0], cmd_cros_tpm_sub,
556 ARRAY_SIZE(cmd_cros_tpm_sub));
557 return c ? c->cmd(cmdtp, flag, argc, argv) : cmd_usage(cmdtp);
558 }
559
560 U_BOOT_CMD(tpmtest, 2, 1, do_tpmtest, "TPM tests",
561 "\n\tearly_extend\n"
562 "\tearly_nvram\n"
563 "\tearly_nvram2\n"
564 "\tenable\n"
565 "\tfast_enable\n"
566 "\tglobal_lock\n"
567 "\tlock\n"
568 "\treadonly\n"
569 "\tredefine_unowned\n"
570 "\tspace_perm\n"
571 "\tstartup\n"
572 "\ttiming\n"
573 "\twrite_limit\n");
574