Skip to contentSkip to conversation

tpm: Enhance sandbox tpm2 emulation

PATCH Superseded Simon Glass 2 participants 18 messages Jul 5, 2021 – Jul 20, 2021

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover tpm: Enhance sandbox tpm2 emulation

At present the TPM2 emulator lacks the ability to load and save the state. This means it cannot be used for verify-boot flow that includes multiple phases (e.g. VPL and SPL). It also lacks support for non-volatile data storage.

This series adds these features to the TPM2 emulator, with some code from TPM1 moving into a common file.

A few other clean-ups are included to make the two emulators more similar.

Simon Glass (9):
sandbox: tpm: Split out common nvdata code
sandbox: tpm: Tidy up reading and writing of device state
sandbox: tpm: Support the define-space command
sandbox: tpm: Correct handling of get-capability
sandbox: tpm: Finish comments for struct sandbox_tpm2
sandbox: tpm: Track whether the state is valid
sandbox: tpm: Support nvdata in TPM2
sandbox: tpm: Support storing device state in tpm2
sandbox: tpm: Support extending a PCR multiple times

 drivers/tpm/Makefile           |   4 +-
 drivers/tpm/sandbox_common.c   |  77 ++++++++++
 drivers/tpm/sandbox_common.h   | 108 ++++++++++++++
 drivers/tpm/tpm2_tis_sandbox.c | 256 +++++++++++++++++++++++++++++++--
 drivers/tpm/tpm_tis_sandbox.c  | 171 ++++++----------------
 include/tpm-v2.h               |   2 +
 6 files changed, 479 insertions(+), 139 deletions(-)
 create mode 100644 drivers/tpm/sandbox_common.c
 create mode 100644 drivers/tpm/sandbox_common.h
Signature · 1 line
2.32.0.93.g670b81a890-goog
#1 lore raw

PATCH 1/9 sandbox: tpm: Split out common nvdata code

We want to support nvdata in TPM2 as well. To avoid code duplicating the associated code, move it into a common file.

Drop the special-case logic for the kernel space. This can be handled by the higher-level code now, i.e. in vboot itself.

---

 drivers/tpm/Makefile          |   4 +-
 drivers/tpm/sandbox_common.c  |  66 ++++++++++++++++++++
 drivers/tpm/sandbox_common.h  |  96 +++++++++++++++++++++++++++++
 drivers/tpm/tpm_tis_sandbox.c | 111 +++-------------------------------
 4 files changed, 172 insertions(+), 105 deletions(-)
 create mode 100644 drivers/tpm/sandbox_common.c
 create mode 100644 drivers/tpm/sandbox_common.h
drivers/tpm/Makefile +2 -2
index f64d20067f8..c65be526700 100644
@@ -6,11 +6,11 @@ obj-$(CONFIG_$(SPL_TPL_)TPM) += tpm-uclass.o
 obj-$(CONFIG_TPM_ATMEL_TWI) += tpm_atmel_twi.o
 obj-$(CONFIG_TPM_TIS_INFINEON) += tpm_tis_infineon.o
 obj-$(CONFIG_TPM_TIS_LPC) += tpm_tis_lpc.o
-obj-$(CONFIG_TPM_TIS_SANDBOX) += tpm_tis_sandbox.o
+obj-$(CONFIG_TPM_TIS_SANDBOX) += tpm_tis_sandbox.o sandbox_common.o
 obj-$(CONFIG_TPM_ST33ZP24_I2C) += tpm_tis_st33zp24_i2c.o
 obj-$(CONFIG_TPM_ST33ZP24_SPI) += tpm_tis_st33zp24_spi.o
 
 obj-$(CONFIG_$(SPL_TPL_)TPM2_CR50_I2C) += cr50_i2c.o
-obj-$(CONFIG_TPM2_TIS_SANDBOX) += tpm2_tis_sandbox.o
+obj-$(CONFIG_TPM2_TIS_SANDBOX) += tpm2_tis_sandbox.o sandbox_common.o
 obj-$(CONFIG_TPM2_TIS_SPI) += tpm2_tis_spi.o
 obj-$(CONFIG_TPM2_FTPM_TEE) += tpm2_ftpm_tee.o
drivers/tpm/sandbox_common.c new file +66 -0

66 lines not on this page · raw message

drivers/tpm/sandbox_common.h new file +96 -0

96 lines not on this page · raw message

drivers/tpm/tpm_tis_sandbox.c +8 -103

144 lines not on this page · raw message

Signature · 1 line
2.32.0.93.g670b81a890-goog
#2 lore raw

PATCH 2/9 sandbox: tpm: Tidy up reading and writing of device state

In reply to Simon Glass

At present this code assumes that the TPM data has been read but this may not be the case. Refactor the code to use a separate pointer so we know the current state of the data.

Add error checking for the data size.

---

 drivers/tpm/tpm_tis_sandbox.c | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)
drivers/tpm/tpm_tis_sandbox.c +24 -11
index 294d98da606..f22ed846f0a 100644
@@ -20,7 +20,7 @@
 static struct tpm_state {
 	bool valid;
 	struct nvdata_state nvdata[NV_SEQ_COUNT];
-} g_state;
+} s_state, *g_state;
 
 /**
  * sandbox_tpm_read_state() - read the sandbox EC state from the state file
@@ -33,6 +33,7 @@ static struct tpm_state {
  */
 static int sandbox_tpm_read_state(const void *blob, int node)
 {
+	struct tpm_state *state = &s_state;
 	const char *prop;
 	int len;
 	int i;
@@ -41,22 +42,27 @@ static int sandbox_tpm_read_state(const void *blob, int node)
 		return 0;
 
 	for (i = 0; i < NV_SEQ_COUNT; i++) {
+		struct nvdata_state *nvd = &state->nvdata[i];
 		char prop_name[20];
 
 		sprintf(prop_name, "nvdata%d", i);
 		prop = fdt_getprop(blob, node, prop_name, &len);
-		if (prop && len == NV_DATA_SIZE) {
-			memcpy(g_state.nvdata[i].data, prop, NV_DATA_SIZE);
-			g_state.nvdata[i].present = true;
+		if (len >= NV_DATA_SIZE)
+			return log_msg_ret("nvd", -E2BIG);
+		if (prop) {
+			memcpy(nvd->data, prop, len);
+			nvd->length = len;
+			nvd->present = true;
 		}
 	}
-	g_state.valid = true;
+
+	s_state.valid = true;
 
 	return 0;
 }
 
 /**
- * cros_ec_write_state() - Write out our state to the state file
+ * sandbox_tpm_write_state() - Write out our state to the state file
  *
  * The caller will ensure that there is a node ready for the state. The node
  * may already contain the old state, in which case it is overridden.
@@ -66,20 +72,25 @@ static int sandbox_tpm_read_state(const void *blob, int node)
  */
 static int sandbox_tpm_write_state(void *blob, int node)
 {
+	const struct tpm_state *state = g_state;
 	int i;
 
+	if (!state)
+		return 0;
+
 	/*
 	 * We are guaranteed enough space to write basic properties.
 	 * We could use fdt_add_subnode() to put each set of data in its
 	 * own node - perhaps useful if we add access informaiton to each.
 	 */
 	for (i = 0; i < NV_SEQ_COUNT; i++) {
+		const struct nvdata_state *nvd = &state->nvdata[i];
 		char prop_name[20];
 
-		if (g_state.nvdata[i].present) {
-			sprintf(prop_name, "nvdata%d", i);
-			fdt_setprop(blob, node, prop_name,
-				    g_state.nvdata[i].data, NV_DATA_SIZE);
+		if (nvd->present) {
+			snprintf(prop_name, sizeof(prop_name), "nvdata%d", i);
+			fdt_setprop(blob, node, prop_name, nvd->data,
+				    nvd->length);
 		}
 	}
 
@@ -233,7 +244,9 @@ static int sandbox_tpm_probe(struct udevice *dev)
 {
 	struct tpm_state *tpm = dev_get_priv(dev);
 
-	memcpy(tpm, &g_state, sizeof(*tpm));
+	if (s_state.valid)
+		memcpy(tpm, &s_state, sizeof(*tpm));
+	g_state = tpm;
 
 	return 0;
 }
Signature · 1 line
2.32.0.93.g670b81a890-goog
#3 lore raw

PATCH 3/9 sandbox: tpm: Support the define-space command

In reply to Simon Glass

Add support for this command, moving away from the previous approach of hard-coding the initial data in the driver, now that the kernel-space data has to be set up by the higher-level vboot code.

---

 drivers/tpm/sandbox_common.c  | 11 +++++++++++
 drivers/tpm/sandbox_common.h  | 12 ++++++++++++
 drivers/tpm/tpm_tis_sandbox.c | 11 +++++++++++
 3 files changed, 34 insertions(+)
drivers/tpm/sandbox_common.c +11 -0
index 13f5e030a5f..7e0b2502e35 100644
@@ -64,3 +64,14 @@ void sb_tpm_write_data(struct nvdata_state nvdata[NV_SEQ_COUNT],
 	else
 		memcpy(&nvdata[seq].data, buf + data_ofs, length);
 }
+
+void sb_tpm_define_data(struct nvdata_state nvdata[NV_SEQ_COUNT],
+			enum sandbox_nv_space seq, int length)
+{
+	struct nvdata_state *nvd = &nvdata[seq];
+
+	if (length > NV_DATA_SIZE)
+		log_err("Invalid length %x (max %x)\n", length, NV_DATA_SIZE);
+	nvd->length = length;
+	nvd->present = true;
+}
drivers/tpm/sandbox_common.h +12 -0
index aa5292d7945..e822a200fd3 100644
@@ -93,4 +93,16 @@ void sb_tpm_write_data(struct nvdata_state nvdata[NV_SEQ_COUNT],
 		       enum sandbox_nv_space seq, const u8 *buf, int data_ofs,
 		       int length);
 
+/**
+ * sb_tpm_define_data() - Set up non-volatile data
+ *
+ * If @length is too large, an error is logged and nothing is written.
+ *
+ * @nvdata: Current nvdata state
+ * @seq: Sequence number to set up
+ * @length: Length of space in bytes
+ */
+void sb_tpm_define_data(struct nvdata_state nvdata[NV_SEQ_COUNT],
+			enum sandbox_nv_space seq, int length);
+
 #endif
drivers/tpm/tpm_tis_sandbox.c +11 -0
index f22ed846f0a..85b22afa4d9 100644
@@ -210,6 +210,17 @@ static int sandbox_tpm_xfer(struct udevice *dev, const uint8_t *sendbuf,
 		memset(recvbuf, '\0', *recv_len);
 		break;
 	case TPM_CMD_NV_DEFINE_SPACE:
+		index = get_unaligned_be32(sendbuf + 12);
+		length = get_unaligned_be32(sendbuf + 77);
+		seq = sb_tpm_index_to_seq(index);
+		if (seq < 0)
+			return -EINVAL;
+		printf("tpm: define_space index=%#02x, len=%#02x, seq=%#02x\n",
+		       index, length, seq);
+		sb_tpm_define_data(tpm->nvdata, seq, length);
+		*recv_len = 12;
+		memset(recvbuf, '\0', *recv_len);
+		break;
 	case 0x15: /* pcr read */
 	case 0x5d: /* force clear */
 	case 0x6f: /* physical enable */
Signature · 1 line
2.32.0.93.g670b81a890-goog
#4 lore raw

PATCH 4/9 sandbox: tpm: Correct handling of get-capability

In reply to Simon Glass

This function current handles the kernel case incorrectly. Fix it, and use the shorter TPM_HDR_LEN while we are here.

---

 drivers/tpm/tpm_tis_sandbox.c | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)
drivers/tpm/tpm_tis_sandbox.c +4 -10
index 85b22afa4d9..efbeb00ab63 100644
@@ -140,16 +140,13 @@ static int sandbox_tpm_xfer(struct udevice *dev, const uint8_t *sendbuf,
 			printf("Get flags index %#02x\n", index);
 			*recv_len = 22;
 			memset(recvbuf, '\0', *recv_len);
-			data = recvbuf + TPM_RESPONSE_HEADER_LENGTH +
-					sizeof(uint32_t);
+			data = recvbuf + TPM_HDR_LEN + sizeof(uint32_t);
 			switch (index) {
 			case FIRMWARE_NV_INDEX:
 				break;
 			case KERNEL_NV_INDEX:
 				handle_cap_flag_space(&data, index);
-				*recv_len = data - recvbuf -
-					TPM_RESPONSE_HEADER_LENGTH -
-					sizeof(uint32_t);
+				*recv_len = data - recvbuf;
 				break;
 			case TPM_CAP_FLAG_PERMANENT: {
 				struct tpm_permanent_flags *pflags;
@@ -166,15 +163,12 @@ static int sandbox_tpm_xfer(struct udevice *dev, const uint8_t *sendbuf,
 				printf("   ** Unknown flags index %x\n", index);
 				return -ENOSYS;
 			}
-			put_unaligned_be32(*recv_len,
-					   recvbuf +
-					   TPM_RESPONSE_HEADER_LENGTH);
+			put_unaligned_be32(*recv_len, recvbuf + TPM_HDR_LEN);
 			break;
 		case TPM_CAP_NV_INDEX:
 			index = get_unaligned_be32(sendbuf + 18);
 			printf("Get cap nv index %#02x\n", index);
-			put_unaligned_be32(22, recvbuf +
-					   TPM_RESPONSE_HEADER_LENGTH);
+			put_unaligned_be32(22, recvbuf + TPM_HDR_LEN);
 			break;
 		default:
 			printf("   ** Unknown 0x65 command type %#02x\n",
Signature · 1 line
2.32.0.93.g670b81a890-goog
#5 lore raw

Re: [PATCH 4/9] sandbox: tpm: Correct handling of get-capability

Hi Simon,

Quoted 19 lines · Simon Glass

This function current handles the kernel case incorrectly. Fix it, and use the shorter TPM_HDR_LEN while we are here.

---

 drivers/tpm/tpm_tis_sandbox.c | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)
drivers/tpm/tpm_tis_sandbox.c +0 -2
index 85b22afa4d9..efbeb00ab63 100644
@@ -140,16 +140,13 @@ static int sandbox_tpm_xfer(struct udevice *dev, const uint8_t *sendbuf,
 			printf("Get flags index %#02x\n", index);
 			*recv_len = 22;
 			memset(recvbuf, '\0', *recv_len);
-			data = recvbuf + TPM_RESPONSE_HEADER_LENGTH +
-					sizeof(uint32_t);

drivers/tpm/tpm_tis_sandbox.c static int sandbox_tpm_xfer(struct udevice *dev, const uint8_t *sendbuf, · line 149

Quoted 10 lines
drivers/tpm/tpm_tis_sandbox.c +2 -3
+			data = recvbuf + TPM_HDR_LEN + sizeof(uint32_t);
 			switch (index) {
 			case FIRMWARE_NV_INDEX:
 				break;
 			case KERNEL_NV_INDEX:
 				handle_cap_flag_space(&data, index);
-				*recv_len = data - recvbuf -
-					TPM_RESPONSE_HEADER_LENGTH -
-					sizeof(uint32_t);
+				*recv_len = data - recvbuf;

This is the only actual fix right?
TPM_RESPONSE_HEADER_LENGTH and TPM_HDR_LEN are both defined to 10? Is it worth updating the commit message with exactly the problem that was fixed?

Quoted 24 lines
drivers/tpm/tpm_tis_sandbox.c +2 -5
 				break;
 			case TPM_CAP_FLAG_PERMANENT: {
 				struct tpm_permanent_flags *pflags;
@@ -166,15 +163,12 @@ static int sandbox_tpm_xfer(struct udevice *dev, const uint8_t *sendbuf,
 				printf("   ** Unknown flags index %x\n", index);
 				return -ENOSYS;
 			}
-			put_unaligned_be32(*recv_len,
-					   recvbuf +
-					   TPM_RESPONSE_HEADER_LENGTH);
+			put_unaligned_be32(*recv_len, recvbuf + TPM_HDR_LEN);
 			break;
 		case TPM_CAP_NV_INDEX:
 			index = get_unaligned_be32(sendbuf + 18);
 			printf("Get cap nv index %#02x\n", index);
-			put_unaligned_be32(22, recvbuf +
-					   TPM_RESPONSE_HEADER_LENGTH);
+			put_unaligned_be32(22, recvbuf + TPM_HDR_LEN);
 			break;
 		default:
 			printf("   ** Unknown 0x65 command type %#02x\n",
Signature · 1 line
2.32.0.93.g670b81a890-goog
#6 lore raw

PATCH 5/9 sandbox: tpm: Finish comments for struct sandbox_tpm2

In reply to Simon Glass

Tidy up the missing comments for this struct.

---

 drivers/tpm/tpm2_tis_sandbox.c | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +16 -4
index 24c804a5645..5e0bd304699 100644
@@ -45,19 +45,31 @@ static const u8 sandbox_extended_once_pcr[] = {
 	0xea, 0x98, 0x31, 0xa9, 0x27, 0x59, 0xfb, 0x4b,
 };
 
+/*
+ * Information about our TPM emulation. This is preserved in the sandbox
+ * state file if enabled.
+ *
+ * @init_done: true if open() has been called
+ * @startup_done: true if TPM2_CC_STARTUP has been processed
+ * @tests_done: true if TPM2_CC_SELF_TEST has be processed
+ * @pw: TPM password per hierarchy
+ * @pw_sz: Size of each password in bytes
+ * @properties: TPM properties
+ * @pcr: TPM Platform Configuration Registers. Each of these holds a hash and
+ *	can be 'extended' a number of times, meaning another hash is added into
+ *	its value (initial value all zeroes)
+ * @pcr_extensions: Number of times each PCR has been extended (starts at 0)
+ * @nvdata: non-volatile data, used to store important things for the platform
+ */
 struct sandbox_tpm2 {
 	/* TPM internal states */
 	bool init_done;
 	bool startup_done;
 	bool tests_done;
-	/* TPM password per hierarchy */
 	char pw[TPM2_HIERARCHY_NB][TPM2_DIGEST_LEN + 1];
 	int pw_sz[TPM2_HIERARCHY_NB];
-	/* TPM properties */
 	u32 properties[TPM2_PROPERTY_NB];
-	/* TPM PCRs */
 	u8 pcr[SANDBOX_TPM_PCR_NB][TPM2_DIGEST_LEN];
-	/* TPM PCR extensions */
 	u32 pcr_extensions[SANDBOX_TPM_PCR_NB];
 };
 
Signature · 1 line
2.32.0.93.g670b81a890-goog
Acked-by on v1 5/9
#7 lore raw

Re: [PATCH 5/9] sandbox: tpm: Finish comments for struct sandbox_tpm2

Quoted 51 lines · Simon Glass

Tidy up the missing comments for this struct.

---

 drivers/tpm/tpm2_tis_sandbox.c | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +16 -4
index 24c804a5645..5e0bd304699 100644
@@ -45,19 +45,31 @@ static const u8 sandbox_extended_once_pcr[] = {
 	0xea, 0x98, 0x31, 0xa9, 0x27, 0x59, 0xfb, 0x4b,
 };
 
+/*
+ * Information about our TPM emulation. This is preserved in the sandbox
+ * state file if enabled.
+ *
+ * @init_done: true if open() has been called
+ * @startup_done: true if TPM2_CC_STARTUP has been processed
+ * @tests_done: true if TPM2_CC_SELF_TEST has be processed
+ * @pw: TPM password per hierarchy
+ * @pw_sz: Size of each password in bytes
+ * @properties: TPM properties
+ * @pcr: TPM Platform Configuration Registers. Each of these holds a hash and
+ *	can be 'extended' a number of times, meaning another hash is added into
+ *	its value (initial value all zeroes)
+ * @pcr_extensions: Number of times each PCR has been extended (starts at 0)
+ * @nvdata: non-volatile data, used to store important things for the platform
+ */
 struct sandbox_tpm2 {
 	/* TPM internal states */
 	bool init_done;
 	bool startup_done;
 	bool tests_done;
-	/* TPM password per hierarchy */
 	char pw[TPM2_HIERARCHY_NB][TPM2_DIGEST_LEN + 1];
 	int pw_sz[TPM2_HIERARCHY_NB];
-	/* TPM properties */
 	u32 properties[TPM2_PROPERTY_NB];
-	/* TPM PCRs */
 	u8 pcr[SANDBOX_TPM_PCR_NB][TPM2_DIGEST_LEN];
-	/* TPM PCR extensions */
 	u32 pcr_extensions[SANDBOX_TPM_PCR_NB];
 };
 
Signature · 1 line
2.32.0.93.g670b81a890-goog
#8 lore raw

PATCH 6/9 sandbox: tpm: Track whether the state is valid

In reply to Simon Glass

Add checking as to whether the current TPM state is valid, so we can implement reading/writing the state.

---

 drivers/tpm/tpm2_tis_sandbox.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +8 -2
index 5e0bd304699..c287ca2278f 100644
@@ -49,6 +49,7 @@ static const u8 sandbox_extended_once_pcr[] = {
  * Information about our TPM emulation. This is preserved in the sandbox
  * state file if enabled.
  *
+ * @valid: true if this is valid (only used in s_state)
  * @init_done: true if open() has been called
  * @startup_done: true if TPM2_CC_STARTUP has been processed
  * @tests_done: true if TPM2_CC_SELF_TEST has be processed
@@ -62,6 +63,7 @@ static const u8 sandbox_extended_once_pcr[] = {
  * @nvdata: non-volatile data, used to store important things for the platform
  */
 struct sandbox_tpm2 {
+	bool valid;
 	/* TPM internal states */
 	bool init_done;
 	bool startup_done;
@@ -73,6 +75,8 @@ struct sandbox_tpm2 {
 	u32 pcr_extensions[SANDBOX_TPM_PCR_NB];
 };
 
+static struct sandbox_tpm2 s_state, *g_state;
+
 /*
  * Check the tag validity depending on the command (authentication required or
  * not). If authentication is required, check it is valid. Update the auth
@@ -606,11 +610,13 @@ static int sandbox_tpm2_probe(struct udevice *dev)
 	/* Use the TPM v2 stack */
 	priv->version = TPM_V2;
 
-	memset(tpm, 0, sizeof(*tpm));
-
 	priv->pcr_count = 32;
 	priv->pcr_select_min = 2;
 
+	if (s_state.valid)
+		memcpy(tpm, &s_state, sizeof(*tpm));
+	g_state = tpm;
+
 	return 0;
 }
 
Signature · 1 line
2.32.0.93.g670b81a890-goog
#9 lore raw

PATCH 7/9 sandbox: tpm: Support nvdata in TPM2

In reply to Simon Glass

Add support for this feature in the TPM2 emulator, to support Chromium OS vboot.

---

 drivers/tpm/tpm2_tis_sandbox.c | 68 ++++++++++++++++++++++++++++++++++
 include/tpm-v2.h               |  2 +
 2 files changed, 70 insertions(+)
drivers/tpm/tpm2_tis_sandbox.c +68 -0
index c287ca2278f..1d38a79a867 100644
@@ -11,6 +11,7 @@
 #include <asm/unaligned.h>
 #include <linux/bitops.h>
 #include <u-boot/crc.h>
+#include "sandbox_common.h"
 
 /* Hierarchies */
 enum tpm2_hierarchy {
@@ -73,6 +74,7 @@ struct sandbox_tpm2 {
 	u32 properties[TPM2_PROPERTY_NB];
 	u8 pcr[SANDBOX_TPM_PCR_NB][TPM2_DIGEST_LEN];
 	u32 pcr_extensions[SANDBOX_TPM_PCR_NB];
+	struct nvdata_state nvdata[NV_SEQ_COUNT];
 };
 
 static struct sandbox_tpm2 s_state, *g_state;
@@ -109,6 +111,10 @@ static int sandbox_tpm2_check_session(struct udevice *dev, u32 command, u16 tag,
 	case TPM2_CC_DAM_RESET:
 	case TPM2_CC_DAM_PARAMETERS:
 	case TPM2_CC_PCR_EXTEND:
+	case TPM2_CC_NV_READ:
+	case TPM2_CC_NV_WRITE:
+	case TPM2_CC_NV_WRITELOCK:
+	case TPM2_CC_NV_DEFINE_SPACE:
 		if (tag != TPM2_ST_SESSIONS) {
 			printf("Session required for command 0x%x\n", command);
 			return TPM2_RC_AUTH_CONTEXT;
@@ -137,6 +143,10 @@ static int sandbox_tpm2_check_session(struct udevice *dev, u32 command, u16 tag,
 			break;
 		case TPM2_RH_PLATFORM:
 			*hierarchy = TPM2_HIERARCHY_PLATFORM;
+			if (command == TPM2_CC_NV_READ ||
+			    command == TPM2_CC_NV_WRITE ||
+			    command == TPM2_CC_NV_WRITELOCK)
+				*auth += sizeof(u32);
 			break;
 		default:
 			printf("Wrong handle 0x%x\n", handle);
@@ -573,6 +583,64 @@ static int sandbox_tpm2_xfer(struct udevice *dev, const u8 *sendbuf,
 		sandbox_tpm2_fill_buf(recv, recv_len, tag, rc);
 		break;
 
+	case TPM2_CC_NV_READ: {
+		int index, seq;
+
+		index = get_unaligned_be32(sendbuf + TPM2_HDR_LEN + 4);
+		length = get_unaligned_be16(sent);
+		/* ignore offset */
+		seq = sb_tpm_index_to_seq(index);
+		if (seq < 0)
+			return log_msg_ret("index", -EINVAL);
+		printf("tpm: nvread index=%#02x, len=%#02x, seq=%#02x\n", index,
+		       length, seq);
+		*recv_len = TPM2_HDR_LEN + 6 + length;
+		memset(recvbuf, '\0', *recv_len);
+		put_unaligned_be32(length, recvbuf + 2);
+		sb_tpm_read_data(tpm->nvdata, seq, recvbuf,
+				 TPM2_HDR_LEN + 4 + 2, length);
+		break;
+	}
+	case TPM2_CC_NV_WRITE: {
+		int index, seq;
+
+		index = get_unaligned_be32(sendbuf + TPM2_HDR_LEN + 4);
+		length = get_unaligned_be16(sent);
+		sent += sizeof(u16);
+
+		/* ignore offset */
+		seq = sb_tpm_index_to_seq(index);
+		if (seq < 0)
+			return log_msg_ret("index", -EINVAL);
+		printf("tpm: nvwrite index=%#02x, len=%#02x, seq=%#02x\n", index,
+		       length, seq);
+		memcpy(&tpm->nvdata[seq].data, sent, length);
+		tpm->nvdata[seq].present = true;
+		*recv_len = TPM2_HDR_LEN + 2;
+		memset(recvbuf, '\0', *recv_len);
+		break;
+	}
+	case TPM2_CC_NV_DEFINE_SPACE: {
+		int policy_size, index, seq;
+
+		policy_size = get_unaligned_be16(sent + 12);
+		index = get_unaligned_be32(sent + 2);
+		sent += 14 + policy_size;
+		length = get_unaligned_be16(sent);
+		seq = sb_tpm_index_to_seq(index);
+		if (seq < 0)
+			return -EINVAL;
+		printf("tpm: define_space index=%x, len=%x, seq=%x, policy_size=%x\n",
+		       index, length, seq, policy_size);
+		sb_tpm_define_data(tpm->nvdata, seq, length);
+		*recv_len = 12;
+		memset(recvbuf, '\0', *recv_len);
+		break;
+	}
+	case TPM2_CC_NV_WRITELOCK:
+		*recv_len = 12;
+		memset(recvbuf, '\0', *recv_len);
+		break;
 	default:
 		printf("TPM2 command %02x unknown in Sandbox\n", command);
 		rc = TPM2_RC_COMMAND_CODE;
include/tpm-v2.h +2 -0
index 247b3869676..949a13c917a 100644
@@ -32,6 +32,8 @@ struct udevice;
 #define TPM2_MAX_TPM_PROPERTIES ((TPM2_MAX_CAP_BUFFER - sizeof(u32) /* TPM2_CAP */ - \
 				 sizeof(u32)) / sizeof(struct tpms_tagged_property))
 
+#define TPM2_HDR_LEN		10
+
 /*
  *  We deviate from this draft of the specification by increasing the value of
  *  TPM2_NUM_PCR_BANKS from 3 to 16 to ensure compatibility with TPM2
Signature · 1 line
2.32.0.93.g670b81a890-goog
#10 lore raw

PATCH 8/9 sandbox: tpm: Support storing device state in tpm2

In reply to Simon Glass

At present the tpm2 emulator does not support storing the device state. Add this so we can handle the normal vboot flow through the sandbox executables (VPL->SPL etc.) with the TPM contents staying in place.

Note: sandbox has not yet been converted to use livetree for the state information, since livetree does not yet support writing to the tree.

---

 drivers/tpm/tpm2_tis_sandbox.c | 139 +++++++++++++++++++++++++++++++++
 1 file changed, 139 insertions(+)
drivers/tpm/tpm2_tis_sandbox.c +139 -0
index 1d38a79a867..ed9c9a0bc9f 100644
@@ -79,6 +79,145 @@ struct sandbox_tpm2 {
 
 static struct sandbox_tpm2 s_state, *g_state;
 
+/**
+ * sandbox_tpm2_read_state() - read the sandbox EC state from the state file
+ *
+ * If data is available, then blob and node will provide access to it. If
+ * not this function sets up an empty TPM.
+ *
+ * @blob: Pointer to device tree blob, or NULL if no data to read
+ * @node: Node offset to read from
+ */
+static int sandbox_tpm2_read_state(const void *blob, int node)
+{
+	struct sandbox_tpm2 *state = &s_state;
+	char prop_name[20];
+	const char *prop;
+	int len;
+	int i;
+
+	if (!blob)
+		return 0;
+	state->tests_done = fdtdec_get_int(blob, node, "tests-done", 0);
+
+	for (i = 0; i < TPM2_HIERARCHY_NB; i++) {
+		snprintf(prop_name, sizeof(prop_name), "pw%d", i);
+
+		prop = fdt_getprop(blob, node, prop_name, &len);
+		if (len > TPM2_DIGEST_LEN)
+			return log_msg_ret("pw", -E2BIG);
+		if (prop) {
+			memcpy(state->pw[i], prop, len);
+			state->pw_sz[i] = len;
+		}
+	}
+
+	for (i = 0; i < TPM2_PROPERTY_NB; i++) {
+		snprintf(prop_name, sizeof(prop_name), "properties%d", i);
+		state->properties[i] = fdtdec_get_uint(blob, node, prop_name,
+						       0);
+	}
+
+	for (i = 0; i < SANDBOX_TPM_PCR_NB; i++) {
+		int subnode;
+
+		snprintf(prop_name, sizeof(prop_name), "pcr%d", i);
+		subnode = fdt_subnode_offset(blob, node, prop_name);
+		if (subnode < 0)
+			continue;
+		prop = fdt_getprop(blob, subnode, "value", &len);
+		if (len != TPM2_DIGEST_LEN)
+			return log_msg_ret("pcr", -E2BIG);
+		memcpy(state->pcr[i], prop, TPM2_DIGEST_LEN);
+		state->pcr_extensions[i] = fdtdec_get_uint(blob, subnode,
+							   "extensions", 0);
+	}
+
+	for (i = 0; i < NV_SEQ_COUNT; i++) {
+		struct nvdata_state *nvd = &state->nvdata[i];
+
+		sprintf(prop_name, "nvdata%d", i);
+		prop = fdt_getprop(blob, node, prop_name, &len);
+		if (len > NV_DATA_SIZE)
+			return log_msg_ret("nvd", -E2BIG);
+		if (prop) {
+			memcpy(nvd->data, prop, len);
+			nvd->length = len;
+			nvd->present = true;
+		}
+	}
+	s_state.valid = true;
+
+	return 0;
+}
+
+/**
+ * sandbox_tpm2_write_state() - Write out our state to the state file
+ *
+ * The caller will ensure that there is a node ready for the state. The node
+ * may already contain the old state, in which case it is overridden.
+ *
+ * @blob: Device tree blob holding state
+ * @node: Node to write our state into
+ */
+static int sandbox_tpm2_write_state(void *blob, int node)
+{
+	const struct sandbox_tpm2 *state = g_state;
+	char prop_name[20];
+	int i;
+
+	if (!state)
+		return 0;
+
+	/*
+	 * We are guaranteed enough space to write basic properties. This is
+	 * SANDBOX_STATE_MIN_SPACE.
+	 *
+	 * We could use fdt_add_subnode() to put each set of data in its
+	 * own node - perhaps useful if we add access information to each.
+	 */
+	fdt_setprop_u32(blob, node, "tests-done", state->tests_done);
+
+	for (i = 0; i < TPM2_HIERARCHY_NB; i++) {
+		if (state->pw_sz[i]) {
+			snprintf(prop_name, sizeof(prop_name), "pw%d", i);
+			fdt_setprop(blob, node, prop_name, state->pw[i],
+				    state->pw_sz[i]);
+		}
+	}
+
+	for (i = 0; i < TPM2_PROPERTY_NB; i++) {
+		snprintf(prop_name, sizeof(prop_name), "properties%d", i);
+		fdt_setprop_u32(blob, node, prop_name, state->properties[i]);
+	}
+
+	for (i = 0; i < SANDBOX_TPM_PCR_NB; i++) {
+		int subnode;
+
+		snprintf(prop_name, sizeof(prop_name), "pcr%d", i);
+		subnode = fdt_add_subnode(blob, node, prop_name);
+		fdt_setprop(blob, subnode, "value", state->pcr[i],
+			    TPM2_DIGEST_LEN);
+		fdt_setprop_u32(blob, subnode, "extensions",
+				state->pcr_extensions[i]);
+	}
+
+	for (i = 0; i < NV_SEQ_COUNT; i++) {
+		const struct nvdata_state *nvd = &state->nvdata[i];
+
+		if (nvd->present) {
+			snprintf(prop_name, sizeof(prop_name), "nvdata%d", i);
+			fdt_setprop(blob, node, prop_name, nvd->data,
+				    nvd->length);
+		}
+	}
+
+	return 0;
+}
+
+SANDBOX_STATE_IO(sandbox_tpm2, "sandbox,tpm2", sandbox_tpm2_read_state,
+		 sandbox_tpm2_write_state);
+
 /*
  * Check the tag validity depending on the command (authentication required or
  * not). If authentication is required, check it is valid. Update the auth
Signature · 1 line
2.32.0.93.g670b81a890-goog
#11 lore raw

PATCH 9/9 sandbox: tpm: Support extending a PCR multiple times

In reply to Simon Glass

It is fairly easy to handle this case and it makes the emulator more useful, since PCRs are commonly extended several times.

Add support for this, using U-Boot's sha256 support.

---

 drivers/tpm/tpm2_tis_sandbox.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +12 -7
index ed9c9a0bc9f..e84bcc7c4c8 100644
@@ -11,6 +11,7 @@
 #include <asm/unaligned.h>
 #include <linux/bitops.h>
 #include <u-boot/crc.h>
+#include <u-boot/sha256.h>
 #include "sandbox_common.h"
 
 /* Hierarchies */
@@ -407,15 +408,19 @@ static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index,
 			       const u8 *extension)
 {
 	struct sandbox_tpm2 *tpm = dev_get_priv(dev);
-	int i;
 
-	/* Only simulate the first extensions from all '0' with only '0' */
-	for (i = 0; i < TPM2_DIGEST_LEN; i++)
-		if (tpm->pcr[pcr_index][i] || extension[i])
-			return TPM2_RC_FAILURE;
+	if (!pcr_index) {
+		memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
+		       TPM2_DIGEST_LEN);
+	} else {
+		sha256_context ctx;
+
+		sha256_starts(&ctx);
+		sha256_update(&ctx, tpm->pcr[pcr_index], TPM2_DIGEST_LEN);
+		sha256_update(&ctx, extension, TPM2_DIGEST_LEN);
+		sha256_finish(&ctx, tpm->pcr[pcr_index]);
+	}
 
-	memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
-	       TPM2_DIGEST_LEN);
 	tpm->pcr_extensions[pcr_index]++;
 
 	return 0;
Signature · 1 line
2.32.0.93.g670b81a890-goog
#12 lore raw

Re: [PATCH 9/9] sandbox: tpm: Support extending a PCR multiple times

Quoted 26 lines · Simon Glass

It is fairly easy to handle this case and it makes the emulator more useful, since PCRs are commonly extended several times.

Add support for this, using U-Boot's sha256 support.

---

 drivers/tpm/tpm2_tis_sandbox.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +1 -0
index ed9c9a0bc9f..e84bcc7c4c8 100644
@@ -11,6 +11,7 @@
 #include <asm/unaligned.h>
 #include <linux/bitops.h>
 #include <u-boot/crc.h>
+#include <u-boot/sha256.h>
 #include "sandbox_common.h"
 
 /* Hierarchies */
@@ -407,15 +408,19 @@ static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index,
 			       const u8 *extension)
 {

drivers/tpm/tpm2_tis_sandbox.c static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index, · line 414

Quoted 10 lines
drivers/tpm/tpm2_tis_sandbox.c +3 -5
 	struct sandbox_tpm2 *tpm = dev_get_priv(dev);
-	int i;
 
-	/* Only simulate the first extensions from all '0' with only '0' */
-	for (i = 0; i < TPM2_DIGEST_LEN; i++)
-		if (tpm->pcr[pcr_index][i] || extension[i])
-			return TPM2_RC_FAILURE;
+	if (!pcr_index) {
+		memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
+		       TPM2_DIGEST_LEN);

Why do we have to treat pcr 0 specially?
Can't we just get rid of sandbox_extended_once_pcr and just extend all the PCRs with the value wee get?

Quoted 17 lines
drivers/tpm/tpm2_tis_sandbox.c +8 -2
+	} else {
+		sha256_context ctx;
+
+		sha256_starts(&ctx);
+		sha256_update(&ctx, tpm->pcr[pcr_index], TPM2_DIGEST_LEN);
+		sha256_update(&ctx, extension, TPM2_DIGEST_LEN);
+		sha256_finish(&ctx, tpm->pcr[pcr_index]);
+	}
 
-	memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
-	       TPM2_DIGEST_LEN);
 	tpm->pcr_extensions[pcr_index]++;
 
 	return 0;
Signature · 1 line
2.32.0.93.g670b81a890-goog
#13 lore raw

Re: [PATCH 9/9] sandbox: tpm: Support extending a PCR multiple times

Quoted 31 lines · Ilias Apalodimas
Quoted 29 lines · Simon Glass

It is fairly easy to handle this case and it makes the emulator more useful, since PCRs are commonly extended several times.

Add support for this, using U-Boot's sha256 support.

---

 drivers/tpm/tpm2_tis_sandbox.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +1 -1
index ed9c9a0bc9f..e84bcc7c4c8 100644
@@ -11,6 +11,7 @@
 #include <asm/unaligned.h>
 #include <linux/bitops.h>
 #include <u-boot/crc.h>
+#include <u-boot/sha256.h>
 #include "sandbox_common.h"
 
 /* Hierarchies */
@@ -407,15 +408,19 @@ static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index,
                             const u8 *extension)
 {
      struct sandbox_tpm2 *tpm = dev_get_priv(dev);
-     int i;
 
Quoted 12 lines

drivers/tpm/tpm2_tis_sandbox.c static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index, · line 414

Quoted 7 lines
drivers/tpm/tpm2_tis_sandbox.c +3 -4
-     /* Only simulate the first extensions from all '0' with only '0' */
-     for (i = 0; i < TPM2_DIGEST_LEN; i++)
-             if (tpm->pcr[pcr_index][i] || extension[i])
-                     return TPM2_RC_FAILURE;
+     if (!pcr_index) {
+             memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
+                    TPM2_DIGEST_LEN);

Why do we have to treat pcr 0 specially?
Can't we just get rid of sandbox_extended_once_pcr and just extend all the PCRs with the value wee get?

Also looking at the entire series, SANDBOX_TPM_PCR_NB doesn't seem to change. I don't know too much about the tpm sandbox, but that effectively limits us to a single PCR?

Quoted 17 lines
Quoted 17 lines
drivers/tpm/tpm2_tis_sandbox.c +8 -3
+     } else {
+             sha256_context ctx;
+
+             sha256_starts(&ctx);
+             sha256_update(&ctx, tpm->pcr[pcr_index], TPM2_DIGEST_LEN);
+             sha256_update(&ctx, extension, TPM2_DIGEST_LEN);
+             sha256_finish(&ctx, tpm->pcr[pcr_index]);
+     }
 
-     memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
-            TPM2_DIGEST_LEN);
      tpm->pcr_extensions[pcr_index]++;
 
      return 0;
--

2.32.0.93.g670b81a890-goog

#14 lore raw

Re: [PATCH 9/9] sandbox: tpm: Support extending a PCR multiple times

Hi Ilias,

Quoted 47 lines · Ilias Apalodimas
Quoted 31 lines · Ilias Apalodimas
Quoted 29 lines · Simon Glass

It is fairly easy to handle this case and it makes the emulator more useful, since PCRs are commonly extended several times.

Add support for this, using U-Boot's sha256 support.

---

 drivers/tpm/tpm2_tis_sandbox.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +1 -1
index ed9c9a0bc9f..e84bcc7c4c8 100644
@@ -11,6 +11,7 @@
 #include <asm/unaligned.h>
 #include <linux/bitops.h>
 #include <u-boot/crc.h>
+#include <u-boot/sha256.h>
 #include "sandbox_common.h"
 
 /* Hierarchies */
@@ -407,15 +408,19 @@ static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index,
                             const u8 *extension)
 {
      struct sandbox_tpm2 *tpm = dev_get_priv(dev);
-     int i;
 
Quoted 12 lines

drivers/tpm/tpm2_tis_sandbox.c static int sandbox_tpm2_extend(struct udevice *dev, int pcr_index, · line 414

Quoted 7 lines
drivers/tpm/tpm2_tis_sandbox.c +3 -4
-     /* Only simulate the first extensions from all '0' with only '0' */
-     for (i = 0; i < TPM2_DIGEST_LEN; i++)
-             if (tpm->pcr[pcr_index][i] || extension[i])
-                     return TPM2_RC_FAILURE;
+     if (!pcr_index) {
+             memcpy(tpm->pcr[pcr_index], sandbox_extended_once_pcr,
+                    TPM2_DIGEST_LEN);

Why do we have to treat pcr 0 specially?
Can't we just get rid of sandbox_extended_once_pcr and just extend all the PCRs with the value wee get?

Quoted 3 lines

Also looking at the entire series, SANDBOX_TPM_PCR_NB doesn't seem to change. I don't know too much about the tpm sandbox, but that effectively limits us to a single PCR?

I did send an updated series.

That's right, only one PCR is currently used by the tests.

Regards,
Simon

#15 lore raw
In reply to Simon Glass

Hi Ilias,

Quoted 33 lines · Simon Glass

At present the TPM2 emulator lacks the ability to load and save the state. This means it cannot be used for verify-boot flow that includes multiple phases (e.g. VPL and SPL). It also lacks support for non-volatile data storage.

This series adds these features to the TPM2 emulator, with some code from TPM1 moving into a common file.

A few other clean-ups are included to make the two emulators more similar.

Simon Glass (9):
sandbox: tpm: Split out common nvdata code
sandbox: tpm: Tidy up reading and writing of device state
sandbox: tpm: Support the define-space command
sandbox: tpm: Correct handling of get-capability
sandbox: tpm: Finish comments for struct sandbox_tpm2
sandbox: tpm: Track whether the state is valid
sandbox: tpm: Support nvdata in TPM2
sandbox: tpm: Support storing device state in tpm2
sandbox: tpm: Support extending a PCR multiple times

 drivers/tpm/Makefile           |   4 +-
 drivers/tpm/sandbox_common.c   |  77 ++++++++++
 drivers/tpm/sandbox_common.h   | 108 ++++++++++++++
 drivers/tpm/tpm2_tis_sandbox.c | 256 +++++++++++++++++++++++++++++++--
 drivers/tpm/tpm_tis_sandbox.c  | 171 ++++++----------------
 include/tpm-v2.h               |   2 +
 6 files changed, 479 insertions(+), 139 deletions(-)
 create mode 100644 drivers/tpm/sandbox_common.c
 create mode 100644 drivers/tpm/sandbox_common.h
Quoted 3 lines

--
2.32.0.93.g670b81a890-goog

Not sure if you have any comments on this one?

Regards,
Simon

#16 lore raw

Hi Simon,

Unfortunately i had no time to look into this. I'll have a look tomorrow

Cheers
/Ilias

Quoted 45 lines · Simon Glass

Hi Ilias,

Quoted 33 lines · Simon Glass

At present the TPM2 emulator lacks the ability to load and save the state. This means it cannot be used for verify-boot flow that includes multiple phases (e.g. VPL and SPL). It also lacks support for non-volatile data storage.

This series adds these features to the TPM2 emulator, with some code from TPM1 moving into a common file.

A few other clean-ups are included to make the two emulators more similar.

Simon Glass (9):
sandbox: tpm: Split out common nvdata code
sandbox: tpm: Tidy up reading and writing of device state
sandbox: tpm: Support the define-space command
sandbox: tpm: Correct handling of get-capability
sandbox: tpm: Finish comments for struct sandbox_tpm2
sandbox: tpm: Track whether the state is valid
sandbox: tpm: Support nvdata in TPM2
sandbox: tpm: Support storing device state in tpm2
sandbox: tpm: Support extending a PCR multiple times

 drivers/tpm/Makefile           |   4 +-
 drivers/tpm/sandbox_common.c   |  77 ++++++++++
 drivers/tpm/sandbox_common.h   | 108 ++++++++++++++
 drivers/tpm/tpm2_tis_sandbox.c | 256 +++++++++++++++++++++++++++++++--
 drivers/tpm/tpm_tis_sandbox.c  | 171 ++++++----------------
 include/tpm-v2.h               |   2 +
 6 files changed, 479 insertions(+), 139 deletions(-)
 create mode 100644 drivers/tpm/sandbox_common.c
 create mode 100644 drivers/tpm/sandbox_common.h
Quoted 3 lines

--
2.32.0.93.g670b81a890-goog

Not sure if you have any comments on this one?

Regards,
Simon

#17 lore raw

Hi Ilias,

Quoted 4 lines · Ilias Apalodimas

Hi Simon,

Unfortunately i had no time to look into this. I'll have a look tomorrow

OK thanks.

- Simon

Quoted 50 lines

Cheers
/Ilias

Quoted 45 lines · Simon Glass

Hi Ilias,

Quoted 33 lines · Simon Glass

At present the TPM2 emulator lacks the ability to load and save the state. This means it cannot be used for verify-boot flow that includes multiple phases (e.g. VPL and SPL). It also lacks support for non-volatile data storage.

This series adds these features to the TPM2 emulator, with some code from TPM1 moving into a common file.

A few other clean-ups are included to make the two emulators more similar.

Simon Glass (9):
sandbox: tpm: Split out common nvdata code
sandbox: tpm: Tidy up reading and writing of device state
sandbox: tpm: Support the define-space command
sandbox: tpm: Correct handling of get-capability
sandbox: tpm: Finish comments for struct sandbox_tpm2
sandbox: tpm: Track whether the state is valid
sandbox: tpm: Support nvdata in TPM2
sandbox: tpm: Support storing device state in tpm2
sandbox: tpm: Support extending a PCR multiple times

 drivers/tpm/Makefile           |   4 +-
 drivers/tpm/sandbox_common.c   |  77 ++++++++++
 drivers/tpm/sandbox_common.h   | 108 ++++++++++++++
 drivers/tpm/tpm2_tis_sandbox.c | 256 +++++++++++++++++++++++++++++++--
 drivers/tpm/tpm_tis_sandbox.c  | 171 ++++++----------------
 include/tpm-v2.h               |   2 +
 6 files changed, 479 insertions(+), 139 deletions(-)
 create mode 100644 drivers/tpm/sandbox_common.c
 create mode 100644 drivers/tpm/sandbox_common.h
Quoted 3 lines

--
2.32.0.93.g670b81a890-goog

Not sure if you have any comments on this one?

Regards,
Simon