tpm_test.c 14 KB

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