1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2013 The Chromium OS Authors. 4 */ 5 6 #include <common.h> 7 #include <command.h> 8 #include <env.h> 9 #include <malloc.h> 10 #include <asm/unaligned.h> 11 #include <tpm-common.h> 12 #include <tpm-v1.h> 13 #include "tpm-user-utils.h" 14 #include <tpm_api.h> 15 16 static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc, 17 char *const argv[]) 18 { 19 enum tpm_startup_type mode; 20 struct udevice *dev; 21 int rc; 22 23 rc = get_tpm(&dev); 24 if (rc) 25 return rc; 26 if (argc != 2) 27 return CMD_RET_USAGE; 28 if (!strcasecmp("TPM_ST_CLEAR", argv[1])) { 29 mode = TPM_ST_CLEAR; 30 } else if (!strcasecmp("TPM_ST_STATE", argv[1])) { 31 mode = TPM_ST_STATE; 32 } else if (!strcasecmp("TPM_ST_DEACTIVATED", argv[1])) { 33 mode = TPM_ST_DEACTIVATED; 34 } else { 35 printf("Couldn't recognize mode string: %s\n", argv[1]); 36 return CMD_RET_FAILURE; 37 } 38 39 return report_return_code(tpm_startup(dev, mode)); 40 } 41 42 static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc, 43 char *const argv[]) 44 { 45 u32 index, perm, size; 46 struct udevice *dev; 47 int rc; 48 49 rc = get_tpm(&dev); 50 if (rc) 51 return rc; 52 53 if (argc != 4) 54 return CMD_RET_USAGE; 55 index = simple_strtoul(argv[1], NULL, 0); 56 perm = simple_strtoul(argv[2], NULL, 0); 57 size = simple_strtoul(argv[3], NULL, 0); 58 59 return report_return_code(tpm1_nv_define_space(dev, index, perm, size)); 60 } 61 62 static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc, 63 char *const argv[]) 64 { 65 u32 index, count, rc; 66 struct udevice *dev; 67 void *data; 68 69 rc = get_tpm(&dev); 70 if (rc) 71 return rc; 72 73 if (argc != 4) 74 return CMD_RET_USAGE; 75 index = simple_strtoul(argv[1], NULL, 0); 76 data = (void *)simple_strtoul(argv[2], NULL, 0); 77 count = simple_strtoul(argv[3], NULL, 0); 78 79 rc = tpm_nv_read_value(dev, index, data, count); 80 if (!rc) { 81 puts("area content:\n"); 82 print_byte_string(data, count); 83 } 84 85 return report_return_code(rc); 86 } 87 88 static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc, 89 char *const argv[]) 90 { 91 struct udevice *dev; 92 u32 index, rc; 93 size_t count; 94 void *data; 95 96 rc = get_tpm(&dev); 97 if (rc) 98 return rc; 99 100 if (argc != 3) 101 return CMD_RET_USAGE; 102 index = simple_strtoul(argv[1], NULL, 0); 103 data = parse_byte_string(argv[2], NULL, &count); 104 if (!data) { 105 printf("Couldn't parse byte string %s\n", argv[2]); 106 return CMD_RET_FAILURE; 107 } 108 109 rc = tpm_nv_write_value(dev, index, data, count); 110 free(data); 111 112 return report_return_code(rc); 113 } 114 115 static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc, 116 char *const argv[]) 117 { 118 u8 in_digest[20], out_digest[20]; 119 struct udevice *dev; 120 u32 index, rc; 121 122 rc = get_tpm(&dev); 123 if (rc) 124 return rc; 125 126 if (argc != 3) 127 return CMD_RET_USAGE; 128 index = simple_strtoul(argv[1], NULL, 0); 129 if (!parse_byte_string(argv[2], in_digest, NULL)) { 130 printf("Couldn't parse byte string %s\n", argv[2]); 131 return CMD_RET_FAILURE; 132 } 133 134 rc = tpm_pcr_extend(dev, index, in_digest, sizeof(in_digest), 135 out_digest, "cmd"); 136 if (!rc) { 137 puts("PCR value after execution of the command:\n"); 138 print_byte_string(out_digest, sizeof(out_digest)); 139 } 140 141 return report_return_code(rc); 142 } 143 144 static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc, 145 char *const argv[]) 146 { 147 u32 index, count, rc; 148 struct udevice *dev; 149 void *data; 150 151 rc = get_tpm(&dev); 152 if (rc) 153 return rc; 154 155 if (argc != 4) 156 return CMD_RET_USAGE; 157 index = simple_strtoul(argv[1], NULL, 0); 158 data = (void *)simple_strtoul(argv[2], NULL, 0); 159 count = simple_strtoul(argv[3], NULL, 0); 160 161 rc = tpm_pcr_read(dev, index, data, count); 162 if (!rc) { 163 puts("Named PCR content:\n"); 164 print_byte_string(data, count); 165 } 166 167 return report_return_code(rc); 168 } 169 170 static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag, 171 int argc, char *const argv[]) 172 { 173 struct udevice *dev; 174 u16 presence; 175 int rc; 176 177 rc = get_tpm(&dev); 178 if (rc) 179 return rc; 180 181 if (argc != 2) 182 return CMD_RET_USAGE; 183 presence = (u16)simple_strtoul(argv[1], NULL, 0); 184 185 return report_return_code(tpm_tsc_physical_presence(dev, presence)); 186 } 187 188 static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc, 189 char *const argv[]) 190 { 191 struct udevice *dev; 192 u32 count, rc; 193 void *data; 194 195 rc = get_tpm(&dev); 196 if (rc) 197 return rc; 198 199 if (argc != 3) 200 return CMD_RET_USAGE; 201 data = (void *)simple_strtoul(argv[1], NULL, 0); 202 count = simple_strtoul(argv[2], NULL, 0); 203 204 rc = tpm_read_pubek(dev, data, count); 205 if (!rc) { 206 puts("pubek value:\n"); 207 print_byte_string(data, count); 208 } 209 210 return report_return_code(rc); 211 } 212 213 static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag, 214 int argc, char *const argv[]) 215 { 216 struct udevice *dev; 217 u8 state; 218 int rc; 219 220 rc = get_tpm(&dev); 221 if (rc) 222 return rc; 223 224 if (argc != 2) 225 return CMD_RET_USAGE; 226 state = (u8)simple_strtoul(argv[1], NULL, 0); 227 228 return report_return_code(tpm_physical_set_deactivated(dev, state)); 229 } 230 231 static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc, 232 char *const argv[]) 233 { 234 u32 cap_area, sub_cap, rc; 235 void *cap; 236 size_t count; 237 struct udevice *dev; 238 239 rc = get_tpm(&dev); 240 if (rc) 241 return rc; 242 243 if (argc != 5) 244 return CMD_RET_USAGE; 245 cap_area = simple_strtoul(argv[1], NULL, 0); 246 sub_cap = simple_strtoul(argv[2], NULL, 0); 247 cap = (void *)simple_strtoul(argv[3], NULL, 0); 248 count = simple_strtoul(argv[4], NULL, 0); 249 250 rc = tpm_get_capability(dev, cap_area, sub_cap, cap, count); 251 if (!rc) { 252 puts("capability information:\n"); 253 print_byte_string(cap, count); 254 } 255 256 return report_return_code(rc); 257 } 258 259 static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag, int argc, 260 char *const argv[]) 261 { 262 struct udevice *dev; 263 void *command; 264 u8 response[1024]; 265 size_t count, response_length = sizeof(response); 266 u32 rc; 267 268 command = parse_byte_string(argv[1], NULL, &count); 269 if (!command) { 270 printf("Couldn't parse byte string %s\n", argv[1]); 271 return CMD_RET_FAILURE; 272 } 273 274 rc = get_tpm(&dev); 275 if (rc) 276 return rc; 277 278 rc = tpm_xfer(dev, command, count, response, &response_length); 279 free(command); 280 if (!rc) { 281 puts("tpm response:\n"); 282 print_byte_string(response, response_length); 283 } 284 285 return report_return_code(rc); 286 } 287 288 static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc, 289 char *const argv[]) 290 { 291 u32 index, perm, size; 292 struct udevice *dev; 293 int rc; 294 295 rc = get_tpm(&dev); 296 if (rc) 297 return rc; 298 299 if (argc != 4) 300 return CMD_RET_USAGE; 301 size = type_string_get_space_size(argv[1]); 302 if (!size) { 303 printf("Couldn't parse arguments\n"); 304 return CMD_RET_USAGE; 305 } 306 index = simple_strtoul(argv[2], NULL, 0); 307 perm = simple_strtoul(argv[3], NULL, 0); 308 309 return report_return_code(tpm1_nv_define_space(dev, index, perm, size)); 310 } 311 312 static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc, 313 char *const argv[]) 314 { 315 u32 index, count, err; 316 struct udevice *dev; 317 void *data; 318 int rc; 319 320 rc = get_tpm(&dev); 321 if (rc) 322 return rc; 323 324 if (argc < 3) 325 return CMD_RET_USAGE; 326 if (argc != 3 + type_string_get_num_values(argv[1])) 327 return CMD_RET_USAGE; 328 index = simple_strtoul(argv[2], NULL, 0); 329 data = type_string_alloc(argv[1], &count); 330 if (!data) { 331 printf("Couldn't parse arguments\n"); 332 return CMD_RET_USAGE; 333 } 334 335 err = tpm_nv_read_value(dev, index, data, count); 336 if (!err) { 337 if (type_string_write_vars(argv[1], data, argv + 3)) { 338 printf("Couldn't write to variables\n"); 339 err = ~0; 340 } 341 } 342 free(data); 343 344 return report_return_code(err); 345 } 346 347 static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc, 348 char *const argv[]) 349 { 350 u32 index, count, err; 351 struct udevice *dev; 352 void *data; 353 int rc; 354 355 rc = get_tpm(&dev); 356 if (rc) 357 return rc; 358 359 if (argc < 3) 360 return CMD_RET_USAGE; 361 if (argc != 3 + type_string_get_num_values(argv[1])) 362 return CMD_RET_USAGE; 363 index = simple_strtoul(argv[2], NULL, 0); 364 data = type_string_alloc(argv[1], &count); 365 if (!data) { 366 printf("Couldn't parse arguments\n"); 367 return CMD_RET_USAGE; 368 } 369 if (type_string_pack(argv[1], argv + 3, data)) { 370 printf("Couldn't parse arguments\n"); 371 free(data); 372 return CMD_RET_USAGE; 373 } 374 375 err = tpm_nv_write_value(dev, index, data, count); 376 free(data); 377 378 return report_return_code(err); 379 } 380 381 #ifdef CONFIG_TPM_AUTH_SESSIONS 382 383 static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag, int argc, 384 char *const argv[]) 385 { 386 u32 auth_handle, err; 387 struct udevice *dev; 388 int rc; 389 390 rc = get_tpm(&dev); 391 if (rc) 392 return rc; 393 394 err = tpm1_oiap(dev, &auth_handle); 395 396 return report_return_code(err); 397 } 398 399 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1 400 static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, 401 char *const argv[]) 402 { 403 u32 parent_handle = 0; 404 u32 key_len, key_handle, err; 405 u8 usage_auth[DIGEST_LENGTH]; 406 u8 parent_hash[DIGEST_LENGTH]; 407 void *key; 408 struct udevice *dev; 409 410 err = get_tpm(&dev); 411 if (err) 412 return err; 413 414 if (argc < 5) 415 return CMD_RET_USAGE; 416 417 parse_byte_string(argv[1], parent_hash, NULL); 418 key = (void *)simple_strtoul(argv[2], NULL, 0); 419 key_len = simple_strtoul(argv[3], NULL, 0); 420 if (strlen(argv[4]) != 2 * DIGEST_LENGTH) 421 return CMD_RET_FAILURE; 422 parse_byte_string(argv[4], usage_auth, NULL); 423 424 err = tpm1_find_key_sha1(dev, usage_auth, parent_hash, &parent_handle); 425 if (err) { 426 printf("Could not find matching parent key (err = %d)\n", err); 427 return CMD_RET_FAILURE; 428 } 429 430 printf("Found parent key %08x\n", parent_handle); 431 432 err = tpm1_load_key2_oiap(dev, parent_handle, key, key_len, usage_auth, 433 &key_handle); 434 if (!err) { 435 printf("Key handle is 0x%x\n", key_handle); 436 env_set_hex("key_handle", key_handle); 437 } 438 439 return report_return_code(err); 440 } 441 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */ 442 443 static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc, 444 char *const argv[]) 445 { 446 u32 parent_handle, key_len, key_handle, err; 447 u8 usage_auth[DIGEST_LENGTH]; 448 void *key; 449 struct udevice *dev; 450 int rc; 451 452 rc = get_tpm(&dev); 453 if (rc) 454 return rc; 455 456 if (argc < 5) 457 return CMD_RET_USAGE; 458 459 parent_handle = simple_strtoul(argv[1], NULL, 0); 460 key = (void *)simple_strtoul(argv[2], NULL, 0); 461 key_len = simple_strtoul(argv[3], NULL, 0); 462 if (strlen(argv[4]) != 2 * DIGEST_LENGTH) 463 return CMD_RET_FAILURE; 464 parse_byte_string(argv[4], usage_auth, NULL); 465 466 err = tpm1_load_key2_oiap(dev, parent_handle, key, key_len, usage_auth, 467 &key_handle); 468 if (!err) 469 printf("Key handle is 0x%x\n", key_handle); 470 471 return report_return_code(err); 472 } 473 474 static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc, 475 char *const argv[]) 476 { 477 u32 key_handle, err; 478 u8 usage_auth[DIGEST_LENGTH]; 479 u8 pub_key_buffer[TPM_PUBKEY_MAX_LENGTH]; 480 size_t pub_key_len = sizeof(pub_key_buffer); 481 struct udevice *dev; 482 int rc; 483 484 rc = get_tpm(&dev); 485 if (rc) 486 return rc; 487 488 if (argc < 3) 489 return CMD_RET_USAGE; 490 491 key_handle = simple_strtoul(argv[1], NULL, 0); 492 if (strlen(argv[2]) != 2 * DIGEST_LENGTH) 493 return CMD_RET_FAILURE; 494 parse_byte_string(argv[2], usage_auth, NULL); 495 496 err = tpm1_get_pub_key_oiap(dev, key_handle, usage_auth, pub_key_buffer, 497 &pub_key_len); 498 if (!err) { 499 printf("dump of received pub key structure:\n"); 500 print_byte_string(pub_key_buffer, pub_key_len); 501 } 502 return report_return_code(err); 503 } 504 505 TPM_COMMAND_NO_ARG(tpm1_end_oiap) 506 507 #endif /* CONFIG_TPM_AUTH_SESSIONS */ 508 509 #ifdef CONFIG_TPM_FLUSH_RESOURCES 510 static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc, 511 char *const argv[]) 512 { 513 struct udevice *dev; 514 int type = 0; 515 int rc; 516 517 rc = get_tpm(&dev); 518 if (rc) 519 return rc; 520 521 if (argc != 3) 522 return CMD_RET_USAGE; 523 524 if (!strcasecmp(argv[1], "key")) 525 type = TPM_RT_KEY; 526 else if (!strcasecmp(argv[1], "auth")) 527 type = TPM_RT_AUTH; 528 else if (!strcasecmp(argv[1], "hash")) 529 type = TPM_RT_HASH; 530 else if (!strcasecmp(argv[1], "trans")) 531 type = TPM_RT_TRANS; 532 else if (!strcasecmp(argv[1], "context")) 533 type = TPM_RT_CONTEXT; 534 else if (!strcasecmp(argv[1], "counter")) 535 type = TPM_RT_COUNTER; 536 else if (!strcasecmp(argv[1], "delegate")) 537 type = TPM_RT_DELEGATE; 538 else if (!strcasecmp(argv[1], "daa_tpm")) 539 type = TPM_RT_DAA_TPM; 540 else if (!strcasecmp(argv[1], "daa_v0")) 541 type = TPM_RT_DAA_V0; 542 else if (!strcasecmp(argv[1], "daa_v1")) 543 type = TPM_RT_DAA_V1; 544 545 if (!type) { 546 printf("Resource type %s unknown.\n", argv[1]); 547 return -1; 548 } 549 550 if (!strcasecmp(argv[2], "all")) { 551 u16 res_count; 552 u8 buf[288]; 553 u8 *ptr; 554 int err; 555 uint i; 556 557 /* fetch list of already loaded resources in the TPM */ 558 err = tpm_get_capability(dev, TPM_CAP_HANDLE, type, buf, 559 sizeof(buf)); 560 if (err) { 561 printf("tpm_get_capability returned error %d.\n", err); 562 return -1; 563 } 564 res_count = get_unaligned_be16(buf); 565 ptr = buf + 2; 566 for (i = 0; i < res_count; ++i, ptr += 4) 567 tpm1_flush_specific(dev, get_unaligned_be32(ptr), type); 568 } else { 569 u32 handle = simple_strtoul(argv[2], NULL, 0); 570 571 if (!handle) { 572 printf("Illegal resource handle %s\n", argv[2]); 573 return -1; 574 } 575 tpm1_flush_specific(dev, cpu_to_be32(handle), type); 576 } 577 578 return 0; 579 } 580 #endif /* CONFIG_TPM_FLUSH_RESOURCES */ 581 582 #ifdef CONFIG_TPM_LIST_RESOURCES 583 static int do_tpm_list(cmd_tbl_t *cmdtp, int flag, int argc, 584 char *const argv[]) 585 { 586 struct udevice *dev; 587 int type = 0; 588 u16 res_count; 589 u8 buf[288]; 590 u8 *ptr; 591 int err; 592 uint i; 593 594 err = get_tpm(&dev); 595 if (err) 596 return err; 597 598 if (argc != 2) 599 return CMD_RET_USAGE; 600 601 if (!strcasecmp(argv[1], "key")) 602 type = TPM_RT_KEY; 603 else if (!strcasecmp(argv[1], "auth")) 604 type = TPM_RT_AUTH; 605 else if (!strcasecmp(argv[1], "hash")) 606 type = TPM_RT_HASH; 607 else if (!strcasecmp(argv[1], "trans")) 608 type = TPM_RT_TRANS; 609 else if (!strcasecmp(argv[1], "context")) 610 type = TPM_RT_CONTEXT; 611 else if (!strcasecmp(argv[1], "counter")) 612 type = TPM_RT_COUNTER; 613 else if (!strcasecmp(argv[1], "delegate")) 614 type = TPM_RT_DELEGATE; 615 else if (!strcasecmp(argv[1], "daa_tpm")) 616 type = TPM_RT_DAA_TPM; 617 else if (!strcasecmp(argv[1], "daa_v0")) 618 type = TPM_RT_DAA_V0; 619 else if (!strcasecmp(argv[1], "daa_v1")) 620 type = TPM_RT_DAA_V1; 621 622 if (!type) { 623 printf("Resource type %s unknown.\n", argv[1]); 624 return -1; 625 } 626 627 /* fetch list of already loaded resources in the TPM */ 628 err = tpm_get_capability(dev, TPM_CAP_HANDLE, type, buf, 629 sizeof(buf)); 630 if (err) { 631 printf("tpm_get_capability returned error %d.\n", err); 632 return -1; 633 } 634 res_count = get_unaligned_be16(buf); 635 ptr = buf + 2; 636 637 printf("Resources of type %s (%02x):\n", argv[1], type); 638 if (!res_count) { 639 puts("None\n"); 640 } else { 641 for (i = 0; i < res_count; ++i, ptr += 4) 642 printf("Index %d: %08x\n", i, get_unaligned_be32(ptr)); 643 } 644 645 return 0; 646 } 647 #endif /* CONFIG_TPM_LIST_RESOURCES */ 648 649 TPM_COMMAND_NO_ARG(tpm_self_test_full) 650 TPM_COMMAND_NO_ARG(tpm_continue_self_test) 651 TPM_COMMAND_NO_ARG(tpm_force_clear) 652 TPM_COMMAND_NO_ARG(tpm_physical_enable) 653 TPM_COMMAND_NO_ARG(tpm_physical_disable) 654 655 static cmd_tbl_t tpm1_commands[] = { 656 U_BOOT_CMD_MKENT(device, 0, 1, do_tpm_device, "", ""), 657 U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""), 658 U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""), 659 U_BOOT_CMD_MKENT(startup, 0, 1, 660 do_tpm_startup, "", ""), 661 U_BOOT_CMD_MKENT(self_test_full, 0, 1, 662 do_tpm_self_test_full, "", ""), 663 U_BOOT_CMD_MKENT(continue_self_test, 0, 1, 664 do_tpm_continue_self_test, "", ""), 665 U_BOOT_CMD_MKENT(force_clear, 0, 1, 666 do_tpm_force_clear, "", ""), 667 U_BOOT_CMD_MKENT(physical_enable, 0, 1, 668 do_tpm_physical_enable, "", ""), 669 U_BOOT_CMD_MKENT(physical_disable, 0, 1, 670 do_tpm_physical_disable, "", ""), 671 U_BOOT_CMD_MKENT(nv_define_space, 0, 1, 672 do_tpm_nv_define_space, "", ""), 673 U_BOOT_CMD_MKENT(nv_read_value, 0, 1, 674 do_tpm_nv_read_value, "", ""), 675 U_BOOT_CMD_MKENT(nv_write_value, 0, 1, 676 do_tpm_nv_write_value, "", ""), 677 U_BOOT_CMD_MKENT(extend, 0, 1, 678 do_tpm_extend, "", ""), 679 U_BOOT_CMD_MKENT(pcr_read, 0, 1, 680 do_tpm_pcr_read, "", ""), 681 U_BOOT_CMD_MKENT(tsc_physical_presence, 0, 1, 682 do_tpm_tsc_physical_presence, "", ""), 683 U_BOOT_CMD_MKENT(read_pubek, 0, 1, 684 do_tpm_read_pubek, "", ""), 685 U_BOOT_CMD_MKENT(physical_set_deactivated, 0, 1, 686 do_tpm_physical_set_deactivated, "", ""), 687 U_BOOT_CMD_MKENT(get_capability, 0, 1, 688 do_tpm_get_capability, "", ""), 689 U_BOOT_CMD_MKENT(raw_transfer, 0, 1, 690 do_tpm_raw_transfer, "", ""), 691 U_BOOT_CMD_MKENT(nv_define, 0, 1, 692 do_tpm_nv_define, "", ""), 693 U_BOOT_CMD_MKENT(nv_read, 0, 1, 694 do_tpm_nv_read, "", ""), 695 U_BOOT_CMD_MKENT(nv_write, 0, 1, 696 do_tpm_nv_write, "", ""), 697 #ifdef CONFIG_TPM_AUTH_SESSIONS 698 U_BOOT_CMD_MKENT(oiap, 0, 1, 699 do_tpm_oiap, "", ""), 700 U_BOOT_CMD_MKENT(end_oiap, 0, 1, 701 do_tpm1_end_oiap, "", ""), 702 U_BOOT_CMD_MKENT(load_key2_oiap, 0, 1, 703 do_tpm_load_key2_oiap, "", ""), 704 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1 705 U_BOOT_CMD_MKENT(load_key_by_sha1, 0, 1, 706 do_tpm_load_key_by_sha1, "", ""), 707 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */ 708 U_BOOT_CMD_MKENT(get_pub_key_oiap, 0, 1, 709 do_tpm_get_pub_key_oiap, "", ""), 710 #endif /* CONFIG_TPM_AUTH_SESSIONS */ 711 #ifdef CONFIG_TPM_FLUSH_RESOURCES 712 U_BOOT_CMD_MKENT(flush, 0, 1, 713 do_tpm_flush, "", ""), 714 #endif /* CONFIG_TPM_FLUSH_RESOURCES */ 715 #ifdef CONFIG_TPM_LIST_RESOURCES 716 U_BOOT_CMD_MKENT(list, 0, 1, 717 do_tpm_list, "", ""), 718 #endif /* CONFIG_TPM_LIST_RESOURCES */ 719 }; 720 721 cmd_tbl_t *get_tpm1_commands(unsigned int *size) 722 { 723 *size = ARRAY_SIZE(tpm1_commands); 724 725 return tpm1_commands; 726 } 727 728 U_BOOT_CMD(tpm, CONFIG_SYS_MAXARGS, 1, do_tpm, 729 "Issue a TPMv1.x command", 730 "cmd args...\n" 731 " - Issue TPM command <cmd> with arguments <args...>.\n" 732 "Admin Startup and State Commands:\n" 733 " device [num device]\n" 734 " - Show all devices or set the specified device\n" 735 " info - Show information about the TPM\n" 736 " init\n" 737 " - Put TPM into a state where it waits for 'startup' command.\n" 738 " startup mode\n" 739 " - Issue TPM_Starup command. <mode> is one of TPM_ST_CLEAR,\n" 740 " TPM_ST_STATE, and TPM_ST_DEACTIVATED.\n" 741 "Admin Testing Commands:\n" 742 " self_test_full\n" 743 " - Test all of the TPM capabilities.\n" 744 " continue_self_test\n" 745 " - Inform TPM that it should complete the self-test.\n" 746 "Admin Opt-in Commands:\n" 747 " physical_enable\n" 748 " - Set the PERMANENT disable flag to FALSE using physical presence as\n" 749 " authorization.\n" 750 " physical_disable\n" 751 " - Set the PERMANENT disable flag to TRUE using physical presence as\n" 752 " authorization.\n" 753 " physical_set_deactivated 0|1\n" 754 " - Set deactivated flag.\n" 755 "Admin Ownership Commands:\n" 756 " force_clear\n" 757 " - Issue TPM_ForceClear command.\n" 758 " tsc_physical_presence flags\n" 759 " - Set TPM device's Physical Presence flags to <flags>.\n" 760 "The Capability Commands:\n" 761 " get_capability cap_area sub_cap addr count\n" 762 " - Read <count> bytes of TPM capability indexed by <cap_area> and\n" 763 " <sub_cap> to memory address <addr>.\n" 764 #if defined(CONFIG_TPM_FLUSH_RESOURCES) || defined(CONFIG_TPM_LIST_RESOURCES) 765 "Resource management functions\n" 766 #endif 767 #ifdef CONFIG_TPM_FLUSH_RESOURCES 768 " flush resource_type id\n" 769 " - flushes a resource of type <resource_type> (may be one of key, auth,\n" 770 " hash, trans, context, counter, delegate, daa_tpm, daa_v0, daa_v1),\n" 771 " and id <id> from the TPM. Use an <id> of \"all\" to flush all\n" 772 " resources of that type.\n" 773 #endif /* CONFIG_TPM_FLUSH_RESOURCES */ 774 #ifdef CONFIG_TPM_LIST_RESOURCES 775 " list resource_type\n" 776 " - lists resources of type <resource_type> (may be one of key, auth,\n" 777 " hash, trans, context, counter, delegate, daa_tpm, daa_v0, daa_v1),\n" 778 " contained in the TPM.\n" 779 #endif /* CONFIG_TPM_LIST_RESOURCES */ 780 #ifdef CONFIG_TPM_AUTH_SESSIONS 781 "Storage functions\n" 782 " loadkey2_oiap parent_handle key_addr key_len usage_auth\n" 783 " - loads a key data from memory address <key_addr>, <key_len> bytes\n" 784 " into TPM using the parent key <parent_handle> with authorization\n" 785 " <usage_auth> (20 bytes hex string).\n" 786 #ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1 787 " load_key_by_sha1 parent_hash key_addr key_len usage_auth\n" 788 " - loads a key data from memory address <key_addr>, <key_len> bytes\n" 789 " into TPM using the parent hash <parent_hash> (20 bytes hex string)\n" 790 " with authorization <usage_auth> (20 bytes hex string).\n" 791 #endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */ 792 " get_pub_key_oiap key_handle usage_auth\n" 793 " - get the public key portion of a loaded key <key_handle> using\n" 794 " authorization <usage auth> (20 bytes hex string)\n" 795 #endif /* CONFIG_TPM_AUTH_SESSIONS */ 796 "Endorsement Key Handling Commands:\n" 797 " read_pubek addr count\n" 798 " - Read <count> bytes of the public endorsement key to memory\n" 799 " address <addr>\n" 800 "Integrity Collection and Reporting Commands:\n" 801 " extend index digest_hex_string\n" 802 " - Add a new measurement to a PCR. Update PCR <index> with the 20-bytes\n" 803 " <digest_hex_string>\n" 804 " pcr_read index addr count\n" 805 " - Read <count> bytes from PCR <index> to memory address <addr>.\n" 806 #ifdef CONFIG_TPM_AUTH_SESSIONS 807 "Authorization Sessions\n" 808 " oiap\n" 809 " - setup an OIAP session\n" 810 " end_oiap\n" 811 " - terminates an active OIAP session\n" 812 #endif /* CONFIG_TPM_AUTH_SESSIONS */ 813 "Non-volatile Storage Commands:\n" 814 " nv_define_space index permission size\n" 815 " - Establish a space at index <index> with <permission> of <size> bytes.\n" 816 " nv_read_value index addr count\n" 817 " - Read <count> bytes from space <index> to memory address <addr>.\n" 818 " nv_write_value index addr count\n" 819 " - Write <count> bytes from memory address <addr> to space <index>.\n" 820 "Miscellaneous helper functions:\n" 821 " raw_transfer byte_string\n" 822 " - Send a byte string <byte_string> to TPM and print the response.\n" 823 " Non-volatile storage helper functions:\n" 824 " These helper functions treat a non-volatile space as a non-padded\n" 825 " sequence of integer values. These integer values are defined by a type\n" 826 " string, which is a text string of 'bwd' characters: 'b' means a 8-bit\n" 827 " value, 'w' 16-bit value, 'd' 32-bit value. All helper functions take\n" 828 " a type string as their first argument.\n" 829 " nv_define type_string index perm\n" 830 " - Define a space <index> with permission <perm>.\n" 831 " nv_read types_string index vars...\n" 832 " - Read from space <index> to environment variables <vars...>.\n" 833 " nv_write types_string index values...\n" 834 " - Write to space <index> from values <values...>.\n" 835 ); 836