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