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

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2018 Bootlin
   4  * Author: Miquel Raynal <miquel.raynal@bootlin.com>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <log.h>
  10 #include <mapmem.h>
  11 #include <tpm-common.h>
  12 #include <tpm-v2.h>
  13 #include "tpm-user-utils.h"
  14
  15 static int do_tpm2_startup(cmd_tbl_t *cmdtp, int flag, int argc,
  16                            char * const argv[])
  17 {
  18         enum tpm2_startup_types mode;
  19
  20         if (argc != 2)
  21                 return CMD_RET_USAGE;
  22
  23         if (!strcasecmp("TPM2_SU_CLEAR", argv[1])) {
  24                 mode = TPM2_SU_CLEAR;
  25         } else if (!strcasecmp("TPM2_SU_STATE", argv[1])) {
  26                 mode = TPM2_SU_STATE;
  27         } else {
  28                 printf("Couldn't recognize mode string: %s\n", argv[1]);
  29                 return CMD_RET_FAILURE;
  30         }
  31
  32         return report_return_code(tpm2_startup(mode));
  33 }
  34
  35 static int do_tpm2_self_test(cmd_tbl_t *cmdtp, int flag, int argc,
  36                              char * const argv[])
  37 {
  38         enum tpm2_yes_no full_test;
  39
  40         if (argc != 2)
  41                 return CMD_RET_USAGE;
  42
  43         if (!strcasecmp("full", argv[1])) {
  44                 full_test = TPMI_YES;
  45         } else if (!strcasecmp("continue", argv[1])) {
  46                 full_test = TPMI_NO;
  47         } else {
  48                 printf("Couldn't recognize test mode: %s\n", argv[1]);
  49                 return CMD_RET_FAILURE;
  50         }
  51
  52         return report_return_code(tpm2_self_test(full_test));
  53 }
  54
  55 static int do_tpm2_clear(cmd_tbl_t *cmdtp, int flag, int argc,
  56                          char * const argv[])
  57 {
  58         u32 handle = 0;
  59         const char *pw = (argc < 3) ? NULL : argv[2];
  60         const ssize_t pw_sz = pw ? strlen(pw) : 0;
  61
  62         if (argc < 2 || argc > 3)
  63                 return CMD_RET_USAGE;
  64
  65         if (pw_sz > TPM2_DIGEST_LEN)
  66                 return -EINVAL;
  67
  68         if (!strcasecmp("TPM2_RH_LOCKOUT", argv[1]))
  69                 handle = TPM2_RH_LOCKOUT;
  70         else if (!strcasecmp("TPM2_RH_PLATFORM", argv[1]))
  71                 handle = TPM2_RH_PLATFORM;
  72         else
  73                 return CMD_RET_USAGE;
  74
  75         return report_return_code(tpm2_clear(handle, pw, pw_sz));
  76 }
  77
  78 static int do_tpm2_pcr_extend(cmd_tbl_t *cmdtp, int flag, int argc,
  79                               char * const argv[])
  80 {
  81         struct udevice *dev;
  82         struct tpm_chip_priv *priv;
  83         u32 index = simple_strtoul(argv[1], NULL, 0);
  84         void *digest = map_sysmem(simple_strtoul(argv[2], NULL, 0), 0);
  85         int ret;
  86         u32 rc;
  87
  88         if (argc != 3)
  89                 return CMD_RET_USAGE;
  90
  91         ret = uclass_first_device_err(UCLASS_TPM, &dev);
  92         if (ret)
  93                 return ret;
  94
  95         priv = dev_get_uclass_priv(dev);
  96         if (!priv)
  97                 return -EINVAL;
  98
  99         if (index >= priv->pcr_count)
 100                 return -EINVAL;
 101
 102         rc = tpm2_pcr_extend(index, digest);
 103
 104         unmap_sysmem(digest);
 105
 106         return report_return_code(rc);
 107 }
 108
 109 static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
 110                            char * const argv[])
 111 {
 112         struct udevice *dev;
 113         struct tpm_chip_priv *priv;
 114         u32 index, rc;
 115         unsigned int updates;
 116         void *data;
 117         int ret;
 118
 119         if (argc != 3)
 120                 return CMD_RET_USAGE;
 121
 122         ret = uclass_first_device_err(UCLASS_TPM, &dev);
 123         if (ret)
 124                 return ret;
 125
 126         priv = dev_get_uclass_priv(dev);
 127         if (!priv)
 128                 return -EINVAL;
 129
 130         index = simple_strtoul(argv[1], NULL, 0);
 131         if (index >= priv->pcr_count)
 132                 return -EINVAL;
 133
 134         data = map_sysmem(simple_strtoul(argv[2], NULL, 0), 0);
 135
 136         rc = tpm2_pcr_read(index, priv->pcr_select_min, data, &updates);
 137         if (!rc) {
 138                 printf("PCR #%u content (%d known updates):\n", index, updates);
 139                 print_byte_string(data, TPM2_DIGEST_LEN);
 140         }
 141
 142         unmap_sysmem(data);
 143
 144         return report_return_code(rc);
 145 }
 146
 147 static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
 148                                  char * const argv[])
 149 {
 150         u32 capability, property, rc;
 151         u8 *data;
 152         size_t count;
 153         int i, j;
 154
 155         if (argc != 5)
 156                 return CMD_RET_USAGE;
 157
 158         capability = simple_strtoul(argv[1], NULL, 0);
 159         property = simple_strtoul(argv[2], NULL, 0);
 160         data = map_sysmem(simple_strtoul(argv[3], NULL, 0), 0);
 161         count = simple_strtoul(argv[4], NULL, 0);
 162
 163         rc = tpm2_get_capability(capability, property, data, count);
 164         if (rc)
 165                 goto unmap_data;
 166
 167         printf("Capabilities read from TPM:\n");
 168         for (i = 0; i < count; i++) {
 169                 printf("Property 0x");
 170                 for (j = 0; j < 4; j++)
 171                         printf("%02x", data[(i * 8) + j]);
 172                 printf(": 0x");
 173                 for (j = 4; j < 8; j++)
 174                         printf("%02x", data[(i * 8) + j]);
 175                 printf("\n");
 176         }
 177
 178 unmap_data:
 179         unmap_sysmem(data);
 180
 181         return report_return_code(rc);
 182 }
 183
 184 static int do_tpm_dam_reset(cmd_tbl_t *cmdtp, int flag, int argc,
 185                             char *const argv[])
 186 {
 187         const char *pw = (argc < 2) ? NULL : argv[1];
 188         const ssize_t pw_sz = pw ? strlen(pw) : 0;
 189
 190         if (argc > 2)
 191                 return CMD_RET_USAGE;
 192
 193         if (pw_sz > TPM2_DIGEST_LEN)
 194                 return -EINVAL;
 195
 196         return report_return_code(tpm2_dam_reset(pw, pw_sz));
 197 }
 198
 199 static int do_tpm_dam_parameters(cmd_tbl_t *cmdtp, int flag, int argc,
 200                                  char *const argv[])
 201 {
 202         const char *pw = (argc < 5) ? NULL : argv[4];
 203         const ssize_t pw_sz = pw ? strlen(pw) : 0;
 204         /*
 205          * No Dictionary Attack Mitigation (DAM) means:
 206          * maxtries = 0xFFFFFFFF, recovery_time = 1, lockout_recovery = 0
 207          */
 208         unsigned long int max_tries;
 209         unsigned long int recovery_time;
 210         unsigned long int lockout_recovery;
 211
 212         if (argc < 4 || argc > 5)
 213                 return CMD_RET_USAGE;
 214
 215         if (pw_sz > TPM2_DIGEST_LEN)
 216                 return -EINVAL;
 217
 218         if (strict_strtoul(argv[1], 0, &max_tries))
 219                 return CMD_RET_USAGE;
 220
 221         if (strict_strtoul(argv[2], 0, &recovery_time))
 222                 return CMD_RET_USAGE;
 223
 224         if (strict_strtoul(argv[3], 0, &lockout_recovery))
 225                 return CMD_RET_USAGE;
 226
 227         log(LOGC_NONE, LOGL_INFO, "Changing dictionary attack parameters:\n");
 228         log(LOGC_NONE, LOGL_INFO, "- maxTries: %lu", max_tries);
 229         log(LOGC_NONE, LOGL_INFO, "- recoveryTime: %lu\n", recovery_time);
 230         log(LOGC_NONE, LOGL_INFO, "- lockoutRecovery: %lu\n", lockout_recovery);
 231
 232         return report_return_code(tpm2_dam_parameters(pw, pw_sz, max_tries,
 233                                                       recovery_time,
 234                                                       lockout_recovery));
 235 }
 236
 237 static int do_tpm_change_auth(cmd_tbl_t *cmdtp, int flag, int argc,
 238                               char *const argv[])
 239 {
 240         u32 handle;
 241         const char *newpw = argv[2];
 242         const char *oldpw = (argc == 3) ? NULL : argv[3];
 243         const ssize_t newpw_sz = strlen(newpw);
 244         const ssize_t oldpw_sz = oldpw ? strlen(oldpw) : 0;
 245
 246         if (argc < 3 || argc > 4)
 247                 return CMD_RET_USAGE;
 248
 249         if (newpw_sz > TPM2_DIGEST_LEN || oldpw_sz > TPM2_DIGEST_LEN)
 250                 return -EINVAL;
 251
 252         if (!strcasecmp("TPM2_RH_LOCKOUT", argv[1]))
 253                 handle = TPM2_RH_LOCKOUT;
 254         else if (!strcasecmp("TPM2_RH_ENDORSEMENT", argv[1]))
 255                 handle = TPM2_RH_ENDORSEMENT;
 256         else if (!strcasecmp("TPM2_RH_OWNER", argv[1]))
 257                 handle = TPM2_RH_OWNER;
 258         else if (!strcasecmp("TPM2_RH_PLATFORM", argv[1]))
 259                 handle = TPM2_RH_PLATFORM;
 260         else
 261                 return CMD_RET_USAGE;
 262
 263         return report_return_code(tpm2_change_auth(handle, newpw, newpw_sz,
 264                                                    oldpw, oldpw_sz));
 265 }
 266
 267 static int do_tpm_pcr_setauthpolicy(cmd_tbl_t *cmdtp, int flag, int argc,
 268                                     char * const argv[])
 269 {
 270         u32 index = simple_strtoul(argv[1], NULL, 0);
 271         char *key = argv[2];
 272         const char *pw = (argc < 4) ? NULL : argv[3];
 273         const ssize_t pw_sz = pw ? strlen(pw) : 0;
 274
 275         if (strlen(key) != TPM2_DIGEST_LEN)
 276                 return -EINVAL;
 277
 278         if (argc < 3 || argc > 4)
 279                 return CMD_RET_USAGE;
 280
 281         return report_return_code(tpm2_pcr_setauthpolicy(pw, pw_sz, index,
 282                                                          key));
 283 }
 284
 285 static int do_tpm_pcr_setauthvalue(cmd_tbl_t *cmdtp, int flag,
 286                                    int argc, char * const argv[])
 287 {
 288         u32 index = simple_strtoul(argv[1], NULL, 0);
 289         char *key = argv[2];
 290         const ssize_t key_sz = strlen(key);
 291         const char *pw = (argc < 4) ? NULL : argv[3];
 292         const ssize_t pw_sz = pw ? strlen(pw) : 0;
 293
 294         if (strlen(key) != TPM2_DIGEST_LEN)
 295                 return -EINVAL;
 296
 297         if (argc < 3 || argc > 4)
 298                 return CMD_RET_USAGE;
 299
 300         return report_return_code(tpm2_pcr_setauthvalue(pw, pw_sz, index,
 301                                                         key, key_sz));
 302 }
 303
 304 static cmd_tbl_t tpm2_commands[] = {
 305         U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""),
 306         U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""),
 307         U_BOOT_CMD_MKENT(startup, 0, 1, do_tpm2_startup, "", ""),
 308         U_BOOT_CMD_MKENT(self_test, 0, 1, do_tpm2_self_test, "", ""),
 309         U_BOOT_CMD_MKENT(clear, 0, 1, do_tpm2_clear, "", ""),
 310         U_BOOT_CMD_MKENT(pcr_extend, 0, 1, do_tpm2_pcr_extend, "", ""),
 311         U_BOOT_CMD_MKENT(pcr_read, 0, 1, do_tpm_pcr_read, "", ""),
 312         U_BOOT_CMD_MKENT(get_capability, 0, 1, do_tpm_get_capability, "", ""),
 313         U_BOOT_CMD_MKENT(dam_reset, 0, 1, do_tpm_dam_reset, "", ""),
 314         U_BOOT_CMD_MKENT(dam_parameters, 0, 1, do_tpm_dam_parameters, "", ""),
 315         U_BOOT_CMD_MKENT(change_auth, 0, 1, do_tpm_change_auth, "", ""),
 316         U_BOOT_CMD_MKENT(pcr_setauthpolicy, 0, 1,
 317                          do_tpm_pcr_setauthpolicy, "", ""),
 318         U_BOOT_CMD_MKENT(pcr_setauthvalue, 0, 1,
 319                          do_tpm_pcr_setauthvalue, "", ""),
 320 };
 321
 322 cmd_tbl_t *get_tpm_commands(unsigned int *size)
 323 {
 324         *size = ARRAY_SIZE(tpm2_commands);
 325
 326         return tpm2_commands;
 327 }
 328
 329 U_BOOT_CMD(tpm, CONFIG_SYS_MAXARGS, 1, do_tpm, "Issue a TPMv2.x command",
 330 "<command> [<arguments>]\n"
 331 "\n"
 332 "info\n"
 333 "    Show information about the TPM.\n"
 334 "init\n"
 335 "    Initialize the software stack. Always the first command to issue.\n"
 336 "startup <mode>\n"
 337 "    Issue a TPM2_Startup command.\n"
 338 "    <mode> is one of:\n"
 339 "        * TPM2_SU_CLEAR (reset state)\n"
 340 "        * TPM2_SU_STATE (preserved state)\n"
 341 "self_test <type>\n"
 342 "    Test the TPM capabilities.\n"
 343 "    <type> is one of:\n"
 344 "        * full (perform all tests)\n"
 345 "        * continue (only check untested tests)\n"
 346 "clear <hierarchy>\n"
 347 "    Issue a TPM2_Clear command.\n"
 348 "    <hierarchy> is one of:\n"
 349 "        * TPM2_RH_LOCKOUT\n"
 350 "        * TPM2_RH_PLATFORM\n"
 351 "pcr_extend <pcr> <digest_addr>\n"
 352 "    Extend PCR #<pcr> with digest at <digest_addr>.\n"
 353 "    <pcr>: index of the PCR\n"
 354 "    <digest_addr>: address of a 32-byte SHA256 digest\n"
 355 "pcr_read <pcr> <digest_addr>\n"
 356 "    Read PCR #<pcr> to memory address <digest_addr>.\n"
 357 "    <pcr>: index of the PCR\n"
 358 "    <digest_addr>: address to store the a 32-byte SHA256 digest\n"
 359 "get_capability <capability> <property> <addr> <count>\n"
 360 "    Read and display <count> entries indexed by <capability>/<property>.\n"
 361 "    Values are 4 bytes long and are written at <addr>.\n"
 362 "    <capability>: capability\n"
 363 "    <property>: property\n"
 364 "    <addr>: address to store <count> entries of 4 bytes\n"
 365 "    <count>: number of entries to retrieve\n"
 366 "dam_reset [<password>]\n"
 367 "    If the TPM is not in a LOCKOUT state, reset the internal error counter.\n"
 368 "    <password>: optional password\n"
 369 "dam_parameters <max_tries> <recovery_time> <lockout_recovery> [<password>]\n"
 370 "    If the TPM is not in a LOCKOUT state, set the DAM parameters\n"
 371 "    <maxTries>: maximum number of failures before lockout,\n"
 372 "                0 means always locking\n"
 373 "    <recoveryTime>: time before decrement of the error counter,\n"
 374 "                    0 means no lockout\n"
 375 "    <lockoutRecovery>: time of a lockout (before the next try),\n"
 376 "                       0 means a reboot is needed\n"
 377 "    <password>: optional password of the LOCKOUT hierarchy\n"
 378 "change_auth <hierarchy> <new_pw> [<old_pw>]\n"
 379 "    <hierarchy>: the hierarchy\n"
 380 "    <new_pw>: new password for <hierarchy>\n"
 381 "    <old_pw>: optional previous password of <hierarchy>\n"
 382 "pcr_setauthpolicy|pcr_setauthvalue <pcr> <key> [<password>]\n"
 383 "    Change the <key> to access PCR #<pcr>.\n"
 384 "    hierarchy and may be empty.\n"
 385 "    /!\\WARNING: untested function, use at your own risks !\n"
 386 "    <pcr>: index of the PCR\n"
 387 "    <key>: secret to protect the access of PCR #<pcr>\n"
 388 "    <password>: optional password of the PLATFORM hierarchy\n"
 389 );