1
2
3
4
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
15static 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
35static 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
55static 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
78static 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
109static 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
147static 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
178unmap_data:
179 unmap_sysmem(data);
180
181 return report_return_code(rc);
182}
183
184static 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
199static 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
206
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
237static 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
267static 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
285static 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
304static 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
322cmd_tbl_t *get_tpm_commands(unsigned int *size)
323{
324 *size = ARRAY_SIZE(tpm2_commands);
325
326 return tpm2_commands;
327}
328
329U_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
