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 ); 390