git.sur5r.net Git - u-boot/blob - cmd/tpm_test.c

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