[thirdparty/u-boot.git] / cmd / tpm-v2.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2018 Bootlin
 * Author: Miquel Raynal <miquel.raynal@bootlin.com>
 */

#include <common.h>
#include <dm.h>
#include <log.h>
#include <mapmem.h>
#include <tpm-common.h>
#include <tpm-v2.h>
#include "tpm-user-utils.h"

static int do_tpm2_startup(cmd_tbl_t *cmdtp, int flag, int argc,
			   char * const argv[])
{
	enum tpm2_startup_types mode;

	if (argc != 2)
		return CMD_RET_USAGE;

	if (!strcasecmp("TPM2_SU_CLEAR", argv[1])) {
		mode = TPM2_SU_CLEAR;
	} else if (!strcasecmp("TPM2_SU_STATE", argv[1])) {
		mode = TPM2_SU_STATE;
	} else {
		printf("Couldn't recognize mode string: %s\n", argv[1]);
		return CMD_RET_FAILURE;
	}

	return report_return_code(tpm2_startup(mode));
}

static int do_tpm2_self_test(cmd_tbl_t *cmdtp, int flag, int argc,
			     char * const argv[])
{
	enum tpm2_yes_no full_test;

	if (argc != 2)
		return CMD_RET_USAGE;

	if (!strcasecmp("full", argv[1])) {
		full_test = TPMI_YES;
	} else if (!strcasecmp("continue", argv[1])) {
		full_test = TPMI_NO;
	} else {
		printf("Couldn't recognize test mode: %s\n", argv[1]);
		return CMD_RET_FAILURE;
	}

	return report_return_code(tpm2_self_test(full_test));
}

static int do_tpm2_clear(cmd_tbl_t *cmdtp, int flag, int argc,
			 char * const argv[])
{
	u32 handle = 0;
	const char *pw = (argc < 3) ? NULL : argv[2];
	const ssize_t pw_sz = pw ? strlen(pw) : 0;

	if (argc < 2 || argc > 3)
		return CMD_RET_USAGE;

	if (pw_sz > TPM2_DIGEST_LEN)
		return -EINVAL;

	if (!strcasecmp("TPM2_RH_LOCKOUT", argv[1]))
		handle = TPM2_RH_LOCKOUT;
	else if (!strcasecmp("TPM2_RH_PLATFORM", argv[1]))
		handle = TPM2_RH_PLATFORM;
	else
		return CMD_RET_USAGE;

	return report_return_code(tpm2_clear(handle, pw, pw_sz));
}

static int do_tpm2_pcr_extend(cmd_tbl_t *cmdtp, int flag, int argc,
			      char * const argv[])
{
	struct udevice *dev;
	struct tpm_chip_priv *priv;
	u32 index = simple_strtoul(argv[1], NULL, 0);
	void *digest = map_sysmem(simple_strtoul(argv[2], NULL, 0), 0);
	int ret;
	u32 rc;

	if (argc != 3)
		return CMD_RET_USAGE;

	ret = uclass_first_device_err(UCLASS_TPM, &dev);
	if (ret)
		return ret;

	priv = dev_get_uclass_priv(dev);
	if (!priv)
		return -EINVAL;

	if (index >= priv->pcr_count)
		return -EINVAL;

	rc = tpm2_pcr_extend(index, digest);

	unmap_sysmem(digest);

	return report_return_code(rc);
}

static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
			   char * const argv[])
{
	struct udevice *dev;
	struct tpm_chip_priv *priv;
	u32 index, rc;
	unsigned int updates;
	void *data;
	int ret;

	if (argc != 3)
		return CMD_RET_USAGE;

	ret = uclass_first_device_err(UCLASS_TPM, &dev);
	if (ret)
		return ret;

	priv = dev_get_uclass_priv(dev);
	if (!priv)
		return -EINVAL;

	index = simple_strtoul(argv[1], NULL, 0);
	if (index >= priv->pcr_count)
		return -EINVAL;

	data = map_sysmem(simple_strtoul(argv[2], NULL, 0), 0);

	rc = tpm2_pcr_read(index, priv->pcr_select_min, data, &updates);
	if (!rc) {
		printf("PCR #%u content (%d known updates):\n", index, updates);
		print_byte_string(data, TPM2_DIGEST_LEN);
	}

	unmap_sysmem(data);

	return report_return_code(rc);
}

static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
				 char * const argv[])
{
	u32 capability, property, rc;
	u8 *data;
	size_t count;
	int i, j;

	if (argc != 5)
		return CMD_RET_USAGE;

	capability = simple_strtoul(argv[1], NULL, 0);
	property = simple_strtoul(argv[2], NULL, 0);
	data = map_sysmem(simple_strtoul(argv[3], NULL, 0), 0);
	count = simple_strtoul(argv[4], NULL, 0);

	rc = tpm2_get_capability(capability, property, data, count);
	if (rc)
		goto unmap_data;

	printf("Capabilities read from TPM:\n");
	for (i = 0; i < count; i++) {
		printf("Property 0x");
		for (j = 0; j < 4; j++)
			printf("%02x", data[(i * 8) + j]);
		printf(": 0x");
		for (j = 4; j < 8; j++)
			printf("%02x", data[(i * 8) + j]);
		printf("\n");
	}

unmap_data:
	unmap_sysmem(data);

	return report_return_code(rc);
}

static int do_tpm_dam_reset(cmd_tbl_t *cmdtp, int flag, int argc,
			    char *const argv[])
{
	const char *pw = (argc < 2) ? NULL : argv[1];
	const ssize_t pw_sz = pw ? strlen(pw) : 0;

	if (argc > 2)
		return CMD_RET_USAGE;

	if (pw_sz > TPM2_DIGEST_LEN)
		return -EINVAL;

	return report_return_code(tpm2_dam_reset(pw, pw_sz));
}

static int do_tpm_dam_parameters(cmd_tbl_t *cmdtp, int flag, int argc,
				 char *const argv[])
{
	const char *pw = (argc < 5) ? NULL : argv[4];
	const ssize_t pw_sz = pw ? strlen(pw) : 0;
	/*
	 * No Dictionary Attack Mitigation (DAM) means:
	 * maxtries = 0xFFFFFFFF, recovery_time = 1, lockout_recovery = 0
	 */
	unsigned long int max_tries;
	unsigned long int recovery_time;
	unsigned long int lockout_recovery;

	if (argc < 4 || argc > 5)
		return CMD_RET_USAGE;

	if (pw_sz > TPM2_DIGEST_LEN)
		return -EINVAL;

	if (strict_strtoul(argv[1], 0, &max_tries))
		return CMD_RET_USAGE;

	if (strict_strtoul(argv[2], 0, &recovery_time))
		return CMD_RET_USAGE;

	if (strict_strtoul(argv[3], 0, &lockout_recovery))
		return CMD_RET_USAGE;

	log(LOGC_NONE, LOGL_INFO, "Changing dictionary attack parameters:\n");
	log(LOGC_NONE, LOGL_INFO, "- maxTries: %lu", max_tries);
	log(LOGC_NONE, LOGL_INFO, "- recoveryTime: %lu\n", recovery_time);
	log(LOGC_NONE, LOGL_INFO, "- lockoutRecovery: %lu\n", lockout_recovery);

	return report_return_code(tpm2_dam_parameters(pw, pw_sz, max_tries,
						      recovery_time,
						      lockout_recovery));
}

static int do_tpm_change_auth(cmd_tbl_t *cmdtp, int flag, int argc,
			      char *const argv[])
{
	u32 handle;
	const char *newpw = argv[2];
	const char *oldpw = (argc == 3) ? NULL : argv[3];
	const ssize_t newpw_sz = strlen(newpw);
	const ssize_t oldpw_sz = oldpw ? strlen(oldpw) : 0;

	if (argc < 3 || argc > 4)
		return CMD_RET_USAGE;

	if (newpw_sz > TPM2_DIGEST_LEN || oldpw_sz > TPM2_DIGEST_LEN)
		return -EINVAL;

	if (!strcasecmp("TPM2_RH_LOCKOUT", argv[1]))
		handle = TPM2_RH_LOCKOUT;
	else if (!strcasecmp("TPM2_RH_ENDORSEMENT", argv[1]))
		handle = TPM2_RH_ENDORSEMENT;
	else if (!strcasecmp("TPM2_RH_OWNER", argv[1]))
		handle = TPM2_RH_OWNER;
	else if (!strcasecmp("TPM2_RH_PLATFORM", argv[1]))
		handle = TPM2_RH_PLATFORM;
	else
		return CMD_RET_USAGE;

	return report_return_code(tpm2_change_auth(handle, newpw, newpw_sz,
						   oldpw, oldpw_sz));
}

static int do_tpm_pcr_setauthpolicy(cmd_tbl_t *cmdtp, int flag, int argc,
				    char * const argv[])
{
	u32 index = simple_strtoul(argv[1], NULL, 0);
	char *key = argv[2];
	const char *pw = (argc < 4) ? NULL : argv[3];
	const ssize_t pw_sz = pw ? strlen(pw) : 0;

	if (strlen(key) != TPM2_DIGEST_LEN)
		return -EINVAL;

	if (argc < 3 || argc > 4)
		return CMD_RET_USAGE;

	return report_return_code(tpm2_pcr_setauthpolicy(pw, pw_sz, index,
							 key));
}

static int do_tpm_pcr_setauthvalue(cmd_tbl_t *cmdtp, int flag,
				   int argc, char * const argv[])
{
	u32 index = simple_strtoul(argv[1], NULL, 0);
	char *key = argv[2];
	const ssize_t key_sz = strlen(key);
	const char *pw = (argc < 4) ? NULL : argv[3];
	const ssize_t pw_sz = pw ? strlen(pw) : 0;

	if (strlen(key) != TPM2_DIGEST_LEN)
		return -EINVAL;

	if (argc < 3 || argc > 4)
		return CMD_RET_USAGE;

	return report_return_code(tpm2_pcr_setauthvalue(pw, pw_sz, index,
							key, key_sz));
}

static cmd_tbl_t tpm2_commands[] = {
	U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""),
	U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""),
	U_BOOT_CMD_MKENT(startup, 0, 1, do_tpm2_startup, "", ""),
	U_BOOT_CMD_MKENT(self_test, 0, 1, do_tpm2_self_test, "", ""),
	U_BOOT_CMD_MKENT(clear, 0, 1, do_tpm2_clear, "", ""),
	U_BOOT_CMD_MKENT(pcr_extend, 0, 1, do_tpm2_pcr_extend, "", ""),
	U_BOOT_CMD_MKENT(pcr_read, 0, 1, do_tpm_pcr_read, "", ""),
	U_BOOT_CMD_MKENT(get_capability, 0, 1, do_tpm_get_capability, "", ""),
	U_BOOT_CMD_MKENT(dam_reset, 0, 1, do_tpm_dam_reset, "", ""),
	U_BOOT_CMD_MKENT(dam_parameters, 0, 1, do_tpm_dam_parameters, "", ""),
	U_BOOT_CMD_MKENT(change_auth, 0, 1, do_tpm_change_auth, "", ""),
	U_BOOT_CMD_MKENT(pcr_setauthpolicy, 0, 1,
			 do_tpm_pcr_setauthpolicy, "", ""),
	U_BOOT_CMD_MKENT(pcr_setauthvalue, 0, 1,
			 do_tpm_pcr_setauthvalue, "", ""),
};

cmd_tbl_t *get_tpm_commands(unsigned int *size)
{
	*size = ARRAY_SIZE(tpm2_commands);

	return tpm2_commands;
}

U_BOOT_CMD(tpm, CONFIG_SYS_MAXARGS, 1, do_tpm, "Issue a TPMv2.x command",
"<command> [<arguments>]\n"
"\n"
"info\n"
"    Show information about the TPM.\n"
"init\n"
"    Initialize the software stack. Always the first command to issue.\n"
"startup <mode>\n"
"    Issue a TPM2_Startup command.\n"
"    <mode> is one of:\n"
"        * TPM2_SU_CLEAR (reset state)\n"
"        * TPM2_SU_STATE (preserved state)\n"
"self_test <type>\n"
"    Test the TPM capabilities.\n"
"    <type> is one of:\n"
"        * full (perform all tests)\n"
"        * continue (only check untested tests)\n"
"clear <hierarchy>\n"
"    Issue a TPM2_Clear command.\n"
"    <hierarchy> is one of:\n"
"        * TPM2_RH_LOCKOUT\n"
"        * TPM2_RH_PLATFORM\n"
"pcr_extend <pcr> <digest_addr>\n"
"    Extend PCR #<pcr> with digest at <digest_addr>.\n"
"    <pcr>: index of the PCR\n"
"    <digest_addr>: address of a 32-byte SHA256 digest\n"
"pcr_read <pcr> <digest_addr>\n"
"    Read PCR #<pcr> to memory address <digest_addr>.\n"
"    <pcr>: index of the PCR\n"
"    <digest_addr>: address to store the a 32-byte SHA256 digest\n"
"get_capability <capability> <property> <addr> <count>\n"
"    Read and display <count> entries indexed by <capability>/<property>.\n"
"    Values are 4 bytes long and are written at <addr>.\n"
"    <capability>: capability\n"
"    <property>: property\n"
"    <addr>: address to store <count> entries of 4 bytes\n"
"    <count>: number of entries to retrieve\n"
"dam_reset [<password>]\n"
"    If the TPM is not in a LOCKOUT state, reset the internal error counter.\n"
"    <password>: optional password\n"
"dam_parameters <max_tries> <recovery_time> <lockout_recovery> [<password>]\n"
"    If the TPM is not in a LOCKOUT state, set the DAM parameters\n"
"    <maxTries>: maximum number of failures before lockout,\n"
"                0 means always locking\n"
"    <recoveryTime>: time before decrement of the error counter,\n"
"                    0 means no lockout\n"
"    <lockoutRecovery>: time of a lockout (before the next try),\n"
"                       0 means a reboot is needed\n"
"    <password>: optional password of the LOCKOUT hierarchy\n"
"change_auth <hierarchy> <new_pw> [<old_pw>]\n"
"    <hierarchy>: the hierarchy\n"
"    <new_pw>: new password for <hierarchy>\n"
"    <old_pw>: optional previous password of <hierarchy>\n"
"pcr_setauthpolicy|pcr_setauthvalue <pcr> <key> [<password>]\n"
"    Change the <key> to access PCR #<pcr>.\n"
"    hierarchy and may be empty.\n"
"    /!\\WARNING: untested function, use at your own risks !\n"
"    <pcr>: index of the PCR\n"
"    <key>: secret to protect the access of PCR #<pcr>\n"
"    <password>: optional password of the PLATFORM hierarchy\n"
);
Commit	Line	Data
ff32245b MR	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>
6284be5a	10	#include <mapmem.h>
ff32245b MR	11	#include <tpm-common.h>
	12	#include <tpm-v2.h>
	13	#include "tpm-user-utils.h"
	14
1922df20 MR	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
2dc6d97e MR	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
bad8ff56 MR	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
6284be5a MR	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
1c4ea8f4 MR	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
69cd8f06 MR	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
da9c3392 MR	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
dc26e913 MR	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
b9dd4fab MR	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
ff32245b MR	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, "", ""),
1922df20	307	U_BOOT_CMD_MKENT(startup, 0, 1, do_tpm2_startup, "", ""),
2dc6d97e	308	U_BOOT_CMD_MKENT(self_test, 0, 1, do_tpm2_self_test, "", ""),
bad8ff56	309	U_BOOT_CMD_MKENT(clear, 0, 1, do_tpm2_clear, "", ""),
6284be5a	310	U_BOOT_CMD_MKENT(pcr_extend, 0, 1, do_tpm2_pcr_extend, "", ""),
1c4ea8f4	311	U_BOOT_CMD_MKENT(pcr_read, 0, 1, do_tpm_pcr_read, "", ""),
69cd8f06	312	U_BOOT_CMD_MKENT(get_capability, 0, 1, do_tpm_get_capability, "", ""),
da9c3392 MR	313	U_BOOT_CMD_MKENT(dam_reset, 0, 1, do_tpm_dam_reset, "", ""),
da9c3392 MR	314	U_BOOT_CMD_MKENT(dam_parameters, 0, 1, do_tpm_dam_parameters, "", ""),
dc26e913	315	U_BOOT_CMD_MKENT(change_auth, 0, 1, do_tpm_change_auth, "", ""),
b9dd4fab MR	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, "", ""),
ff32245b MR	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"
1922df20 MR	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"
2dc6d97e MR	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"
bad8ff56 MR	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"
6284be5a MR	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"
1c4ea8f4 MR	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"
69cd8f06 MR	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"
dc26e913 MR	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"
b9dd4fab MR	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"
ff32245b	389	);