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