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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2013 The Chromium OS Authors.
 */

#include <common.h>
#include <command.h>
#include <dm.h>
#include <env.h>
#include <malloc.h>
#include <asm/unaligned.h>
#include <linux/string.h>
#include <tpm-common.h>
#include <tpm_api.h>
#include "tpm-user-utils.h"

static struct udevice *tpm_dev;

/**
 * Print a byte string in hexdecimal format, 16-bytes per line.
 *
 * @param data		byte string to be printed
 * @param count		number of bytes to be printed
 */
void print_byte_string(u8 *data, size_t count)
{
	int i, print_newline = 0;

	for (i = 0; i < count; i++) {
		printf(" %02x", data[i]);
		print_newline = (i % 16 == 15);
		if (print_newline)
			putc('\n');
	}
	/* Avoid duplicated newline at the end */
	if (!print_newline)
		putc('\n');
}

/**
 * Convert a text string of hexdecimal values into a byte string.
 *
 * @param bytes		text string of hexdecimal values with no space
 *			between them
 * @param data		output buffer for byte string.  The caller has to make
 *			sure it is large enough for storing the output.  If
 *			NULL is passed, a large enough buffer will be allocated,
 *			and the caller must free it.
 * @param count_ptr	output variable for the length of byte string
 * Return: pointer to output buffer
 */
void *parse_byte_string(char *bytes, u8 *data, size_t *count_ptr)
{
	char byte[3];
	size_t count, length;
	int i;

	if (!bytes)
		return NULL;
	length = strlen(bytes);
	count = length / 2;

	if (!data)
		data = malloc(count);
	if (!data)
		return NULL;

	byte[2] = '\0';
	for (i = 0; i < length; i += 2) {
		byte[0] = bytes[i];
		byte[1] = bytes[i + 1];
		data[i / 2] = (u8)hextoul(byte, NULL);
	}

	if (count_ptr)
		*count_ptr = count;

	return data;
}

/**
 * report_return_code() - Report any error and return failure or success
 *
 * @param return_code	TPM command return code
 * Return: value of enum command_ret_t
 */
int report_return_code(int return_code)
{
	if (return_code) {
		printf("Error: %d\n", return_code);
		return CMD_RET_FAILURE;
	} else {
		return CMD_RET_SUCCESS;
	}
}

/**
 * Return number of values defined by a type string.
 *
 * @param type_str	type string
 * Return: number of values of type string
 */
int type_string_get_num_values(const char *type_str)
{
	return strlen(type_str);
}

/**
 * Return total size of values defined by a type string.
 *
 * @param type_str	type string
 * Return: total size of values of type string, or 0 if type string
 *  contains illegal type character.
 */
size_t type_string_get_space_size(const char *type_str)
{
	size_t size;

	for (size = 0; *type_str; type_str++) {
		switch (*type_str) {
		case 'b':
			size += 1;
			break;
		case 'w':
			size += 2;
			break;
		case 'd':
			size += 4;
			break;
		default:
			return 0;
		}
	}

	return size;
}

/**
 * Allocate a buffer large enough to hold values defined by a type
 * string.  The caller has to free the buffer.
 *
 * @param type_str	type string
 * @param count		pointer for storing size of buffer
 * Return: pointer to buffer or NULL on error
 */
void *type_string_alloc(const char *type_str, u32 *count)
{
	void *data;
	size_t size;

	size = type_string_get_space_size(type_str);
	if (!size)
		return NULL;
	data = malloc(size);
	if (data)
		*count = size;

	return data;
}

/**
 * Pack values defined by a type string into a buffer.  The buffer must have
 * large enough space.
 *
 * @param type_str	type string
 * @param values	text strings of values to be packed
 * @param data		output buffer of values
 * Return: 0 on success, non-0 on error
 */
int type_string_pack(const char *type_str, char * const values[],
		     u8 *data)
{
	size_t offset;
	u32 value;

	for (offset = 0; *type_str; type_str++, values++) {
		value = simple_strtoul(values[0], NULL, 0);
		switch (*type_str) {
		case 'b':
			data[offset] = value;
			offset += 1;
			break;
		case 'w':
			put_unaligned_be16(value, data + offset);
			offset += 2;
			break;
		case 'd':
			put_unaligned_be32(value, data + offset);
			offset += 4;
			break;
		default:
			return -1;
		}
	}

	return 0;
}

/**
 * Read values defined by a type string from a buffer, and write these values
 * to environment variables.
 *
 * @param type_str	type string
 * @param data		input buffer of values
 * @param vars		names of environment variables
 * Return: 0 on success, non-0 on error
 */
int type_string_write_vars(const char *type_str, u8 *data,
			   char * const vars[])
{
	size_t offset;
	u32 value;

	for (offset = 0; *type_str; type_str++, vars++) {
		switch (*type_str) {
		case 'b':
			value = data[offset];
			offset += 1;
			break;
		case 'w':
			value = get_unaligned_be16(data + offset);
			offset += 2;
			break;
		case 'd':
			value = get_unaligned_be32(data + offset);
			offset += 4;
			break;
		default:
			return -1;
		}
		if (env_set_ulong(*vars, value))
			return -1;
	}

	return 0;
}

static int tpm_show_device(void)
{
	struct udevice *dev;
	char buf[80];
	int n = 0, rc;

	for_each_tpm_device(dev) {
		rc = tpm_get_desc(dev, buf, sizeof(buf));
		if (rc < 0)
			printf("device %d: can't get info\n", n);
		else
			printf("device %d: %s\n", n, buf);

		n++;
	};

	return 0;
}

static int tpm_set_device(unsigned long num)
{
	struct udevice *dev;
	unsigned long n = 0;
	int rc = CMD_RET_FAILURE;

	for_each_tpm_device(dev) {
		if (n == num) {
			rc = 0;
			break;
		}

		n++;
	}

	if (!rc)
		tpm_dev = dev;

	return rc;
}

int get_tpm(struct udevice **devp)
{
	int rc;

	/*
	 * To keep a backward compatibility with previous code,
	 * if a tpm device is not explicitly set, we set the first one.
	 */
	if (!tpm_dev) {
		rc = tpm_set_device(0);
		if (rc) {
			printf("Couldn't set TPM 0 (rc = %d)\n", rc);
			return CMD_RET_FAILURE;
		}
	}

	if (devp)
		*devp = tpm_dev;

	return 0;
}

int do_tpm_device(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	unsigned long num;
	int rc;

	if (argc == 2) {
		num = dectoul(argv[1], NULL);

		rc = tpm_set_device(num);
		if (rc)
			printf("Couldn't set TPM %lu (rc = %d)\n", num, rc);
	} else {
		rc = tpm_show_device();
	}

	return rc;
}

int do_tpm_info(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	struct udevice *dev;
	char buf[80];
	int rc;

	rc = get_tpm(&dev);
	if (rc)
		return rc;
	rc = tpm_get_desc(dev, buf, sizeof(buf));
	if (rc < 0) {
		printf("Couldn't get TPM info (%d)\n", rc);
		return CMD_RET_FAILURE;
	}
	printf("%s\n", buf);

	return 0;
}

int do_tpm_report_state(struct cmd_tbl *cmdtp, int flag, int argc,
			char *const argv[])
{
	struct udevice *dev;
	char buf[80];
	int rc;

	rc = get_tpm(&dev);
	if (rc)
		return rc;
	rc = tpm_report_state(dev, buf, sizeof(buf));
	if (rc < 0) {
		printf("Couldn't get TPM state (%d)\n", rc);
		return CMD_RET_FAILURE;
	}
	printf("%s\n", buf);

	return 0;
}

int do_tpm_init(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	struct udevice *dev;
	int rc;

	if (argc != 1)
		return CMD_RET_USAGE;
	rc = get_tpm(&dev);
	if (rc)
		return rc;

	return report_return_code(tpm_init(dev));
}

int do_tpm_autostart(struct cmd_tbl *cmdtp, int flag, int argc,
		     char *const argv[])
{
	struct udevice *dev;
	int rc;

	if (argc != 1)
		return CMD_RET_USAGE;
	rc = get_tpm(&dev);
	if (rc)
		return rc;

	return report_return_code(tpm_auto_start(dev));
}

int do_tpm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	struct cmd_tbl *tpm_commands, *cmd;
	struct tpm_chip_priv *priv;
	struct udevice *dev;
	unsigned int size;
	int ret;

	if (argc < 2)
		return CMD_RET_USAGE;

	ret = get_tpm(&dev);
	if (ret)
		return ret;

	priv = dev_get_uclass_priv(dev);

	/* Below getters return NULL if the desired stack is not built */
	switch (priv->version) {
	case TPM_V1:
		tpm_commands = get_tpm1_commands(&size);
		break;
	case TPM_V2:
		tpm_commands = get_tpm2_commands(&size);
		break;
	default:
		tpm_commands = NULL;
	}

	if (!tpm_commands)
		return CMD_RET_USAGE;

	cmd = find_cmd_tbl(argv[1], tpm_commands, size);
	if (!cmd)
		return CMD_RET_USAGE;

	return cmd->cmd(cmdtp, flag, argc - 1, argv + 1);
}
Commit	Line	Data
d677bfe2 MR	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (c) 2013 The Chromium OS Authors.
	4	*/
	5
	6	#include <common.h>
	7	#include <command.h>
	8	#include <dm.h>
168068fb	9	#include <env.h>
336d4615	10	#include <malloc.h>
d677bfe2 MR	11	#include <asm/unaligned.h>
	12	#include <linux/string.h>
	13	#include <tpm-common.h>
e663b2ff	14	#include <tpm_api.h>
d677bfe2 MR	15	#include "tpm-user-utils.h"
d677bfe2 MR	16
3780e2d0 PR	17	static struct udevice *tpm_dev;
3780e2d0 PR	18
d677bfe2 MR	19	/**
	20	* Print a byte string in hexdecimal format, 16-bytes per line.
	21	*
	22	* @param data byte string to be printed
	23	* @param count number of bytes to be printed
	24	*/
	25	void print_byte_string(u8 *data, size_t count)
	26	{
	27	int i, print_newline = 0;
	28
	29	for (i = 0; i < count; i++) {
	30	printf(" %02x", data[i]);
	31	print_newline = (i % 16 == 15);
	32	if (print_newline)
	33	putc('\n');
	34	}
	35	/* Avoid duplicated newline at the end */
	36	if (!print_newline)
	37	putc('\n');
	38	}
	39
	40	/**
	41	* Convert a text string of hexdecimal values into a byte string.
	42	*
	43	* @param bytes text string of hexdecimal values with no space
	44	* between them
	45	* @param data output buffer for byte string. The caller has to make
	46	* sure it is large enough for storing the output. If
	47	* NULL is passed, a large enough buffer will be allocated,
	48	* and the caller must free it.
	49	* @param count_ptr output variable for the length of byte string
185f812c	50	* Return: pointer to output buffer
d677bfe2 MR	51	*/
	52	void parse_byte_string(char bytes, u8 data, size_t count_ptr)
	53	{
	54	char byte[3];
	55	size_t count, length;
	56	int i;
	57
	58	if (!bytes)
	59	return NULL;
	60	length = strlen(bytes);
	61	count = length / 2;
	62
	63	if (!data)
	64	data = malloc(count);
	65	if (!data)
	66	return NULL;
	67
	68	byte[2] = '\0';
	69	for (i = 0; i < length; i += 2) {
	70	byte[0] = bytes[i];
	71	byte[1] = bytes[i + 1];
7e5f460e	72	data[i / 2] = (u8)hextoul(byte, NULL);
d677bfe2 MR	73	}
	74
	75	if (count_ptr)
	76	*count_ptr = count;
	77
	78	return data;
	79	}
	80
	81	/**
	82	* report_return_code() - Report any error and return failure or success
	83	*
	84	* @param return_code TPM command return code
185f812c	85	* Return: value of enum command_ret_t
d677bfe2 MR	86	*/
	87	int report_return_code(int return_code)
	88	{
	89	if (return_code) {
	90	printf("Error: %d\n", return_code);
	91	return CMD_RET_FAILURE;
	92	} else {
	93	return CMD_RET_SUCCESS;
	94	}
	95	}
	96
	97	/**
	98	* Return number of values defined by a type string.
	99	*
	100	* @param type_str type string
185f812c	101	* Return: number of values of type string
d677bfe2 MR	102	*/
	103	int type_string_get_num_values(const char *type_str)
	104	{
	105	return strlen(type_str);
	106	}
	107
	108	/**
	109	* Return total size of values defined by a type string.
	110	*
	111	* @param type_str type string
185f812c	112	* Return: total size of values of type string, or 0 if type string
d677bfe2 MR	113	* contains illegal type character.
	114	*/
	115	size_t type_string_get_space_size(const char *type_str)
	116	{
	117	size_t size;
	118
	119	for (size = 0; *type_str; type_str++) {
	120	switch (*type_str) {
	121	case 'b':
	122	size += 1;
	123	break;
	124	case 'w':
	125	size += 2;
	126	break;
	127	case 'd':
	128	size += 4;
	129	break;
	130	default:
	131	return 0;
	132	}
	133	}
	134
	135	return size;
	136	}
	137
	138	/**
	139	* Allocate a buffer large enough to hold values defined by a type
	140	* string. The caller has to free the buffer.
	141	*
	142	* @param type_str type string
	143	* @param count pointer for storing size of buffer
185f812c	144	* Return: pointer to buffer or NULL on error
d677bfe2 MR	145	*/
	146	void type_string_alloc(const char type_str, u32 *count)
	147	{
	148	void *data;
	149	size_t size;
	150
	151	size = type_string_get_space_size(type_str);
	152	if (!size)
	153	return NULL;
	154	data = malloc(size);
	155	if (data)
	156	*count = size;
	157
	158	return data;
	159	}
	160
	161	/**
	162	* Pack values defined by a type string into a buffer. The buffer must have
	163	* large enough space.
	164	*
	165	* @param type_str type string
	166	* @param values text strings of values to be packed
	167	* @param data output buffer of values
185f812c	168	* Return: 0 on success, non-0 on error
d677bfe2 MR	169	*/
	170	int type_string_pack(const char type_str, char const values[],
	171	u8 *data)
	172	{
	173	size_t offset;
	174	u32 value;
	175
	176	for (offset = 0; *type_str; type_str++, values++) {
	177	value = simple_strtoul(values[0], NULL, 0);
	178	switch (*type_str) {
	179	case 'b':
	180	data[offset] = value;
	181	offset += 1;
	182	break;
	183	case 'w':
	184	put_unaligned_be16(value, data + offset);
	185	offset += 2;
	186	break;
	187	case 'd':
	188	put_unaligned_be32(value, data + offset);
	189	offset += 4;
	190	break;
	191	default:
	192	return -1;
	193	}
	194	}
	195
	196	return 0;
	197	}
	198
	199	/**
	200	* Read values defined by a type string from a buffer, and write these values
	201	* to environment variables.
	202	*
	203	* @param type_str type string
	204	* @param data input buffer of values
	205	* @param vars names of environment variables
185f812c	206	* Return: 0 on success, non-0 on error
d677bfe2 MR	207	*/
	208	int type_string_write_vars(const char type_str, u8 data,
	209	char * const vars[])
	210	{
	211	size_t offset;
	212	u32 value;
	213
	214	for (offset = 0; *type_str; type_str++, vars++) {
	215	switch (*type_str) {
	216	case 'b':
	217	value = data[offset];
	218	offset += 1;
	219	break;
	220	case 'w':
	221	value = get_unaligned_be16(data + offset);
	222	offset += 2;
	223	break;
	224	case 'd':
	225	value = get_unaligned_be32(data + offset);
	226	offset += 4;
	227	break;
	228	default:
	229	return -1;
	230	}
	231	if (env_set_ulong(*vars, value))
	232	return -1;
	233	}
	234
	235	return 0;
	236	}
	237
3780e2d0 PR	238	static int tpm_show_device(void)
	239	{
	240	struct udevice *dev;
	241	char buf[80];
	242	int n = 0, rc;
	243
	244	for_each_tpm_device(dev) {
	245	rc = tpm_get_desc(dev, buf, sizeof(buf));
	246	if (rc < 0)
	247	printf("device %d: can't get info\n", n);
	248	else
	249	printf("device %d: %s\n", n, buf);
	250
	251	n++;
	252	};
	253
	254	return 0;
	255	}
	256
	257	static int tpm_set_device(unsigned long num)
	258	{
	259	struct udevice *dev;
	260	unsigned long n = 0;
	261	int rc = CMD_RET_FAILURE;
	262
	263	for_each_tpm_device(dev) {
	264	if (n == num) {
	265	rc = 0;
	266	break;
	267	}
	268
	269	n++;
	270	}
	271
	272	if (!rc)
	273	tpm_dev = dev;
	274
	275	return rc;
	276	}
	277
d677bfe2 MR	278	int get_tpm(struct udevice **devp)
	279	{
	280	int rc;
	281
3780e2d0 PR	282	/*
	283	* To keep a backward compatibility with previous code,
	284	* if a tpm device is not explicitly set, we set the first one.
	285	*/
	286	if (!tpm_dev) {
	287	rc = tpm_set_device(0);
	288	if (rc) {
	289	printf("Couldn't set TPM 0 (rc = %d)\n", rc);
	290	return CMD_RET_FAILURE;
	291	}
d677bfe2 MR	292	}
d677bfe2 MR	293
3780e2d0 PR	294	if (devp)
	295	*devp = tpm_dev;
	296
d677bfe2 MR	297	return 0;
	298	}
	299
09140113	300	int do_tpm_device(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
3780e2d0 PR	301	{
	302	unsigned long num;
	303	int rc;
	304
	305	if (argc == 2) {
0b1284eb	306	num = dectoul(argv[1], NULL);
3780e2d0 PR	307
	308	rc = tpm_set_device(num);
	309	if (rc)
	310	printf("Couldn't set TPM %lu (rc = %d)\n", num, rc);
	311	} else {
	312	rc = tpm_show_device();
	313	}
	314
	315	return rc;
	316	}
	317
09140113	318	int do_tpm_info(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
d677bfe2 MR	319	{
	320	struct udevice *dev;
	321	char buf[80];
	322	int rc;
	323
	324	rc = get_tpm(&dev);
	325	if (rc)
	326	return rc;
	327	rc = tpm_get_desc(dev, buf, sizeof(buf));
	328	if (rc < 0) {
	329	printf("Couldn't get TPM info (%d)\n", rc);
	330	return CMD_RET_FAILURE;
	331	}
	332	printf("%s\n", buf);
3bb4db4c SG	333
	334	return 0;
	335	}
	336
	337	int do_tpm_report_state(struct cmd_tbl *cmdtp, int flag, int argc,
	338	char *const argv[])
	339	{
	340	struct udevice *dev;
	341	char buf[80];
	342	int rc;
	343
	344	rc = get_tpm(&dev);
	345	if (rc)
	346	return rc;
	347	rc = tpm_report_state(dev, buf, sizeof(buf));
	348	if (rc < 0) {
	349	printf("Couldn't get TPM state (%d)\n", rc);
	350	return CMD_RET_FAILURE;
	351	}
	352	printf("%s\n", buf);
d677bfe2 MR	353
	354	return 0;
	355	}
	356
09140113	357	int do_tpm_init(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
d677bfe2	358	{
abdc7b8a SG	359	struct udevice *dev;
	360	int rc;
	361
d677bfe2 MR	362	if (argc != 1)
d677bfe2 MR	363	return CMD_RET_USAGE;
abdc7b8a SG	364	rc = get_tpm(&dev);
	365	if (rc)
	366	return rc;
d677bfe2	367
abdc7b8a	368	return report_return_code(tpm_init(dev));
d677bfe2 MR	369	}
d677bfe2 MR	370
e663b2ff IA	371	int do_tpm_autostart(struct cmd_tbl *cmdtp, int flag, int argc,
	372	char *const argv[])
	373	{
	374	struct udevice *dev;
	375	int rc;
	376
	377	if (argc != 1)
	378	return CMD_RET_USAGE;
	379	rc = get_tpm(&dev);
	380	if (rc)
	381	return rc;
	382
	383	return report_return_code(tpm_auto_start(dev));
	384	}
	385
09140113	386	int do_tpm(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
d677bfe2	387	{
09140113	388	struct cmd_tbl tpm_commands, cmd;
2a2096ea MR	389	struct tpm_chip_priv *priv;
2a2096ea MR	390	struct udevice *dev;
d677bfe2	391	unsigned int size;
2a2096ea	392	int ret;
d677bfe2 MR	393
	394	if (argc < 2)
	395	return CMD_RET_USAGE;
	396
2a2096ea MR	397	ret = get_tpm(&dev);
	398	if (ret)
	399	return ret;
	400
	401	priv = dev_get_uclass_priv(dev);
	402
	403	/* Below getters return NULL if the desired stack is not built */
	404	switch (priv->version) {
	405	case TPM_V1:
	406	tpm_commands = get_tpm1_commands(&size);
	407	break;
	408	case TPM_V2:
	409	tpm_commands = get_tpm2_commands(&size);
	410	break;
	411	default:
	412	tpm_commands = NULL;
	413	}
	414
	415	if (!tpm_commands)
	416	return CMD_RET_USAGE;
d677bfe2 MR	417
	418	cmd = find_cmd_tbl(argv[1], tpm_commands, size);
	419	if (!cmd)
	420	return CMD_RET_USAGE;
	421
	422	return cmd->cmd(cmdtp, flag, argc - 1, argv + 1);
	423	}