Skip to contentSkip to conversation

tpm: Support boot measurements

PATCH Superseded Eddie James 4 participants 19 messages Feb 22, 2023 – Mar 1, 2023 Library code

v6 of 14 Superseded Latest is v14 →

lore
Share & tools
lore
#0 lore raw

v6 cover tpm: Support boot measurements

This series adds support for measuring the boot images more generically than the existing EFI support. Several EFI functions have been moved to the TPM layer. The series includes optional measurement from the bootm command.
A new test case has been added for the bootm measurement to test the new path, and the sandbox TPM2 driver has been updated to support this use case.
This series is based on Ilias' auto-startup series and Simon's additions.

Changes since v5:
- Re-ordered the patches to put the sandbox TPM driver patch second
- Remove unused platform_get_eventlog in efi_tcg2.c
- First look for tpm_event_log_* properties instead of linux,sml-*
- Fix efi_tcg2.c compilation
- Select SHA* configs
- Remove the !SANDBOX dependency for EFI TCG2
- Only compile in the measurement u-boot command when CONFIG_MEASURED_BOOT is enabled

Changes since v4:
- Remove tcg2_measure_event function and check for NULL data in tcg2_measure_data
- Use tpm_auto_startup
- Fix efi_tcg2.c compilation for removing tcg2_pcr_read function
- Change PCR indexes for initrd and dtb
- Drop u8 casting in measurement test
- Use bullets in documentation

Changes since v3:
- Reordered headers
- Refactored more of EFI code into common code
Removed digest_info structure and instead used the common alg_to_mask
and alg_to_len
Improved event log parsing in common code to get it equivalent to EFI
Common code now extends PCR if previous bootloader stage couldn't No need to allocate memory in the common code, so EFI copies the discovered buffer like it did before
Rename efi measure_event function

Changes since v2:
- Add documentation.
- Changed reserved memory address to the top of the RAM for sandbox dts.
- Add measure state to booti and bootz.
- Skip measurement for EFI images that should be measured

Changes since v1:
- Refactor TPM layer functions to allow EFI system to use them, and remove duplicate EFI functions.
- Add test case
- Drop #ifdefs for bootm
- Add devicetree measurement config option
- Update sandbox TPM driver

Eddie James (6):
tpm: Fix spelling for tpmu_ha union
tpm: sandbox: Update for needed TPM2 capabilities
tpm: Support boot measurements
bootm: Support boot measurement
test: Add sandbox TPM boot measurement
doc: Add measured boot documentation

 arch/sandbox/dts/sandbox.dtsi  |   13 +
 arch/sandbox/dts/test.dts      |   13 +
 boot/Kconfig                   |   23 +
 boot/bootm.c                   |   70 +++
 cmd/booti.c                    |    1 +
 cmd/bootm.c                    |    2 +
 cmd/bootz.c                    |    1 +
 configs/sandbox_defconfig      |    1 +
 doc/usage/index.rst            |    1 +
 doc/usage/measured_boot.rst    |   23 +
 drivers/tpm/tpm2_tis_sandbox.c |  100 ++-
 include/bootm.h                |    2 +
 include/efi_tcg2.h             |   44 --
 include/image.h                |    1 +
 include/test/suites.h          |    1 +
 include/tpm-v2.h               |  246 +++++++-
 lib/Kconfig                    |    4 +
 lib/efi_loader/Kconfig         |    2 -
 lib/efi_loader/efi_tcg2.c      | 1053 +++-----------------------------
 lib/tpm-v2.c                   |  773 +++++++++++++++++++++++
 test/boot/Makefile             |    1 +
 test/boot/measurement.c        |   66 ++
 test/cmd_ut.c                  |    4 +
 23 files changed, 1392 insertions(+), 1053 deletions(-)
 create mode 100644 doc/usage/measured_boot.rst
 create mode 100644 test/boot/measurement.c
Signature · 1 line
2.31.1
#1 lore raw

PATCH v6 1/6 tpm: Fix spelling for tpmu_ha union

tmpu -> tpmu

---
 include/tpm-v2.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
include/tpm-v2.h +2 -2
index 2b6980e441..6684033deb 100644
@@ -169,7 +169,7 @@ struct tcg_pcr_event {
 /**
  * Definition of TPMU_HA Union
  */
-union tmpu_ha {
+union tpmu_ha {
 	u8 sha1[TPM2_SHA1_DIGEST_SIZE];
 	u8 sha256[TPM2_SHA256_DIGEST_SIZE];
 	u8 sm3_256[TPM2_SM3_256_DIGEST_SIZE];
@@ -185,7 +185,7 @@ union tmpu_ha {
  */
 struct tpmt_ha {
 	u16 hash_alg;
-	union tmpu_ha digest;
+	union tpmu_ha digest;
 } __packed;
 
 /**
Signature · 1 line
2.31.1
#2 lore raw

PATCH v6 2/6 tpm: sandbox: Update for needed TPM2 capabilities

In reply to Eddie James

The driver needs to support getting the PCRs in the capabilities command. Fix various other things and support the max number of PCRs for TPM2.
Remove the !SANDBOX dependency for EFI TCG2 as well.

---
Changes since v5:
- Remove the !SANDBOX dependency for EFI TCG2

 drivers/tpm/tpm2_tis_sandbox.c | 100 ++++++++++++++++++++++++---------
 lib/efi_loader/Kconfig         |   2 -
 2 files changed, 72 insertions(+), 30 deletions(-)
drivers/tpm/tpm2_tis_sandbox.c +72 -28
index e4004cfcca..f63c72814f 100644
@@ -22,11 +22,6 @@ enum tpm2_hierarchy {
 	TPM2_HIERARCHY_NB,
 };
 
-/* Subset of supported capabilities */
-enum tpm2_capability {
-	TPM_CAP_TPM_PROPERTIES = 0x6,
-};
-
 /* Subset of supported properties */
 #define TPM2_PROPERTIES_OFFSET 0x0000020E
 
@@ -38,7 +33,8 @@ enum tpm2_cap_tpm_property {
 	TPM2_PROPERTY_NB,
 };
 
-#define SANDBOX_TPM_PCR_NB 1
+#define SANDBOX_TPM_PCR_NB TPM2_MAX_PCRS
+#define SANDBOX_TPM_PCR_SELECT_MAX	((SANDBOX_TPM_PCR_NB + 7) / 8)
 
 /*
  * Information about our TPM emulation. This is preserved in the sandbox
@@ -433,7 +429,7 @@ static int sandbox_tpm2_xfer(struct udevice *dev, const u8 *sendbuf,
 	int i, j;
 
 	/* TPM2_GetProperty */
-	u32 capability, property, property_count;
+	u32 capability, property, property_count, val;
 
 	/* TPM2_PCR_Read/Extend variables */
 	int pcr_index = 0;
@@ -542,19 +538,32 @@ static int sandbox_tpm2_xfer(struct udevice *dev, const u8 *sendbuf,
 	case TPM2_CC_GET_CAPABILITY:
 		capability = get_unaligned_be32(sent);
 		sent += sizeof(capability);
-		if (capability != TPM_CAP_TPM_PROPERTIES) {
-			printf("Sandbox TPM only support TPM_CAPABILITIES\n");
-			return TPM2_RC_HANDLE;
-		}
-
 		property = get_unaligned_be32(sent);
 		sent += sizeof(property);
-		property -= TPM2_PROPERTIES_OFFSET;
-
 		property_count = get_unaligned_be32(sent);
 		sent += sizeof(property_count);
-		if (!property_count ||
-		    property + property_count > TPM2_PROPERTY_NB) {
+
+		switch (capability) {
+		case TPM2_CAP_PCRS:
+			break;
+		case TPM2_CAP_TPM_PROPERTIES:
+			if (!property_count) {
+				rc = TPM2_RC_HANDLE;
+				return sandbox_tpm2_fill_buf(recv, recv_len,
+							     tag, rc);
+			}
+
+			if (property > TPM2_PROPERTIES_OFFSET &&
+			    ((property - TPM2_PROPERTIES_OFFSET) +
+			     property_count > TPM2_PROPERTY_NB)) {
+				rc = TPM2_RC_HANDLE;
+				return sandbox_tpm2_fill_buf(recv, recv_len,
+							     tag, rc);
+			}
+			break;
+		default:
+			printf("Sandbox TPM2 only supports TPM2_CAP_PCRS or "
+			       "TPM2_CAP_TPM_PROPERTIES\n");
 			rc = TPM2_RC_HANDLE;
 			return sandbox_tpm2_fill_buf(recv, recv_len, tag, rc);
 		}
@@ -578,18 +587,53 @@ static int sandbox_tpm2_xfer(struct udevice *dev, const u8 *sendbuf,
 		put_unaligned_be32(capability, recv);
 		recv += sizeof(capability);
 
-		/* Give the number of properties that follow */
-		put_unaligned_be32(property_count, recv);
-		recv += sizeof(property_count);
-
-		/* Fill with the properties */
-		for (i = 0; i < property_count; i++) {
-			put_unaligned_be32(TPM2_PROPERTIES_OFFSET + property +
-					   i, recv);
-			recv += sizeof(property);
-			put_unaligned_be32(tpm->properties[property + i],
-					   recv);
-			recv += sizeof(property);
+		switch (capability) {
+		case TPM2_CAP_PCRS:
+			/* Give the number of algorithms supported - just SHA256 */
+			put_unaligned_be32(1, recv);
+			recv += sizeof(u32);
+
+			/* Give SHA256 algorithm */
+			put_unaligned_be16(TPM2_ALG_SHA256, recv);
+			recv += sizeof(u16);
+
+			/* Select the PCRs supported */
+			*recv = SANDBOX_TPM_PCR_SELECT_MAX;
+			recv++;
+
+			/* Activate all the PCR bits */
+			for (i = 0; i < SANDBOX_TPM_PCR_SELECT_MAX; ++i) {
+				*recv = 0xff;
+				recv++;
+			}
+			break;
+		case TPM2_CAP_TPM_PROPERTIES:
+			/* Give the number of properties that follow */
+			put_unaligned_be32(property_count, recv);
+			recv += sizeof(property_count);
+
+			/* Fill with the properties */
+			for (i = 0; i < property_count; i++) {
+				put_unaligned_be32(property + i, recv);
+				recv += sizeof(property);
+				if (property > TPM2_PROPERTIES_OFFSET) {
+					val = tpm->properties[(property -
+						TPM2_PROPERTIES_OFFSET) + i];
+				} else {
+					switch (property) {
+					case TPM2_PT_PCR_COUNT:
+						val = SANDBOX_TPM_PCR_NB;
+						break;
+					default:
+						val = 0xffffffff;
+						break;
+					}
+				}
+
+				put_unaligned_be32(val, recv);
+				recv += sizeof(property);
+			}
+			break;
 		}
 
 		/* Add trailing \0 */
lib/efi_loader/Kconfig +0 -2
index c5835e6ef6..605719d2b6 100644
@@ -333,8 +333,6 @@ config EFI_TCG2_PROTOCOL
 	bool "EFI_TCG2_PROTOCOL support"
 	default y
 	depends on TPM_V2
-	# Sandbox TPM currently fails on GetCapabilities needed for TCG2
-	depends on !SANDBOX
 	select SHA1
 	select SHA256
 	select SHA384
Signature · 1 line
2.31.1
#3 lore raw

PATCH v6 3/6 tpm: Support boot measurements

In reply to Eddie James

Add TPM2 functions to support boot measurement. This includes starting up the TPM, initializing/appending the event log, and measuring the U-Boot version. Much of the code was used in the EFI subsystem, so remove it there and use the common functions.

---
Changes since v5:
- Remove unused platform_get_eventlog in efi_tcg2.c
- First look for tpm_event_log_* properties instead of linux,sml-*
- Fix efi_tcg2.c compilation
- Select SHA* configs

Changes since v4:
- Remove tcg2_measure_event function and check for NULL data in tcg2_measure_data
- Use tpm_auto_startup
- Fix efi_tcg2.c compilation for removing tcg2_pcr_read function

Changes since v3:
- Reordered headers
- Refactored more of EFI code into common code
Removed digest_info structure and instead used the common alg_to_mask
and alg_to_len
Improved event log parsing in common code to get it equivalent to EFI
Common code now extends PCR if previous bootloader stage couldn't No need to allocate memory in the common code, so EFI copies the discovered buffer like it did before
Rename efi measure_event function

Changes since v1:
- Refactor TPM layer functions to allow EFI system to use them, and remove duplicate EFI functions.

 include/efi_tcg2.h        |   44 --
 include/tpm-v2.h          |  242 +++++++++
 lib/Kconfig               |    4 +
 lib/efi_loader/efi_tcg2.c | 1053 +++----------------------------------
 lib/tpm-v2.c              |  773 +++++++++++++++++++++++++++
 5 files changed, 1095 insertions(+), 1021 deletions(-)
include/efi_tcg2.h +0 -44
index b1c3abd097..b21c5cb3dd 100644
@@ -129,50 +129,6 @@ struct efi_tcg2_boot_service_capability {
 #define BOOT_SERVICE_CAPABILITY_MIN \
 	offsetof(struct efi_tcg2_boot_service_capability, number_of_pcr_banks)
 
-#define TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03 "Spec ID Event03"
-#define TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2 2
-#define TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2 0
-#define TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_ERRATA_TPM2 2
-
-/**
- *  struct TCG_EfiSpecIdEventAlgorithmSize - hashing algorithm information
- *
- *  @algorithm_id:	algorithm defined in enum tpm2_algorithms
- *  @digest_size:	size of the algorithm
- */
-struct tcg_efi_spec_id_event_algorithm_size {
-	u16      algorithm_id;
-	u16      digest_size;
-} __packed;
-
-/**
- * struct TCG_EfiSpecIDEventStruct - content of the event log header
- *
- * @signature:			signature, set to Spec ID Event03
- * @platform_class:		class defined in TCG ACPI Specification
- *				Client  Common Header.
- * @spec_version_minor:		minor version
- * @spec_version_major:		major version
- * @spec_version_errata:	major version
- * @uintn_size:			size of the efi_uintn_t fields used in various
- *				data structures used in this specification.
- *				0x01 indicates u32  and 0x02  indicates u64
- * @number_of_algorithms:	hashing algorithms used in this event log
- * @digest_sizes:		array of number_of_algorithms pairs
- *				1st member defines the algorithm id
- *				2nd member defines the algorithm size
- */
-struct tcg_efi_spec_id_event {
-	u8 signature[16];
-	u32 platform_class;
-	u8 spec_version_minor;
-	u8 spec_version_major;
-	u8 spec_errata;
-	u8 uintn_size;
-	u32 number_of_algorithms;
-	struct tcg_efi_spec_id_event_algorithm_size digest_sizes[];
-} __packed;
-
 /**
  * struct tdEFI_TCG2_FINAL_EVENTS_TABLE - log entries after Get Event Log
  * @version:		version number for this structure
include/tpm-v2.h +242 -0

266 lines not on this page · raw message

lib/Kconfig +4 -0
index 83e5edd73b..7a146c293f 100644
@@ -411,6 +411,10 @@ config TPM
 	bool "Trusted Platform Module (TPM) Support"
 	depends on DM
 	imply DM_RNG
+	select SHA1
+	select SHA256
+	select SHA384
+	select SHA512
 	help
 	  This enables support for TPMs which can be used to provide security
 	  features for your board. The TPM can be connected via LPC or I2C
lib/efi_loader/efi_tcg2.c +76 -977

1,319 lines not on this page · raw message

lib/tpm-v2.c +773 -0

790 lines not on this page · raw message

Signature · 1 line
2.31.1
#4 lore raw

Hi Eddie,

final_event->number_of_events++;

Quoted 886 lines
lib/efi_loader/efi_tcg2.c +30 -708
@@ -350,66 +142,6 @@ static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
 	return ret;
 }
 
-/**
- * platform_get_tpm_device() - retrieve TPM device
- *
- * This function retrieves the udevice implementing a TPM
- *
- * This function may be overridden if special initialization is needed.
- *
- * @dev:	udevice
- * Return:	status code
- */
-__weak efi_status_t platform_get_tpm2_device(struct udevice **dev)
-{
-	for_each_tpm_device(*dev) {
-		/* Only support TPMv2 devices */
-		if (tpm_get_version(*dev) == TPM_V2)
-			return EFI_SUCCESS;
-	}
-
-	return EFI_NOT_FOUND;
-}
-
-/**
- * platform_get_eventlog() - retrieve the eventlog address and size
- *
- * This function retrieves the eventlog address and size if the underlying
- * firmware has done some measurements and passed them.
- *
- * This function may be overridden based on platform specific method of
- * passing the eventlog address and size.
- *
- * @dev:	udevice
- * @addr:	eventlog address
- * @sz:		eventlog size
- * Return:	status code
- */
-__weak efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr,
-					  u32 *sz)
-{
-	const u64 *basep;
-	const u32 *sizep;
-
-	basep = dev_read_prop(dev, "tpm_event_log_addr", NULL);
-	if (!basep)
-		return EFI_NOT_FOUND;
-
-	*addr = be64_to_cpup((__force __be64 *)basep);
-
-	sizep = dev_read_prop(dev, "tpm_event_log_size", NULL);
-	if (!sizep)
-		return EFI_NOT_FOUND;
-
-	*sz = be32_to_cpup((__force __be32 *)sizep);
-	if (*sz == 0) {
-		log_debug("event log empty\n");
-		return EFI_NOT_FOUND;
-	}
-
-	return EFI_SUCCESS;
-}
-
 /**
  * tpm2_get_max_command_size() - get the supported max command size
  *
@@ -485,239 +217,6 @@ static int tpm2_get_manufacturer_id(struct udevice *dev, u32 *manufacturer_id)
 	return 0;
 }
 
-/**
- * tpm2_get_num_pcr() - get the number of PCRs
- *
- * @dev:		TPM device
- * @manufacturer_id:	output buffer for the number
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_num_pcr(struct udevice *dev, u32 *num_pcr)
-{
-	u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-	u32 ret;
-
-	memset(response, 0, sizeof(response));
-	ret = tpm2_get_capability(dev, TPM2_CAP_TPM_PROPERTIES,
-				  TPM2_PT_PCR_COUNT, response, 1);
-	if (ret)
-		return -1;
-
-	*num_pcr = get_unaligned_be32(response + properties_offset);
-	if (*num_pcr > TPM2_MAX_PCRS)
-		return -1;
-
-	return 0;
-}
-
-/**
- * is_active_pcr() - Check if a supported algorithm is active
- *
- * @dev:		TPM device
- * @selection:		struct of PCR information
- *
- * Return: true if PCR is active
- */
-static bool is_active_pcr(struct tpms_pcr_selection *selection)
-{
-	int i;
-	/*
-	 * check the pcr_select. If at least one of the PCRs supports the
-	 * algorithm add it on the active ones
-	 */
-	for (i = 0; i < selection->size_of_select; i++) {
-		if (selection->pcr_select[i])
-			return true;
-	}
-
-	return false;
-}
-
-/**
- * tpm2_get_pcr_info() - get the supported, active PCRs and number of banks
- *
- * @dev:		TPM device
- * @supported_pcr:	bitmask with the algorithms supported
- * @active_pcr:		bitmask with the active algorithms
- * @pcr_banks:		number of PCR banks
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_pcr_info(struct udevice *dev, u32 *supported_pcr,
-			     u32 *active_pcr, u32 *pcr_banks)
-{
-	u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-	struct tpml_pcr_selection pcrs;
-	u32 ret, num_pcr;
-	size_t i;
-	int tpm_ret;
-
-	*supported_pcr = 0;
-	*active_pcr = 0;
-	*pcr_banks = 0;
-	memset(response, 0, sizeof(response));
-	ret = tpm2_get_capability(dev, TPM2_CAP_PCRS, 0, response, 1);
-	if (ret)
-		goto out;
-
-	pcrs.count = get_unaligned_be32(response);
-	/*
-	 * We only support 5 algorithms for now so check against that
-	 * instead of TPM2_NUM_PCR_BANKS
-	 */
-	if (pcrs.count > MAX_HASH_COUNT || pcrs.count < 1)
-		goto out;
-
-	tpm_ret = tpm2_get_num_pcr(dev, &num_pcr);
-	if (tpm_ret)
-		goto out;
-
-	for (i = 0; i < pcrs.count; i++) {
-		/*
-		 * Definition of TPMS_PCR_SELECTION Structure
-		 * hash: u16
-		 * size_of_select: u8
-		 * pcr_select: u8 array
-		 *
-		 * The offsets depend on the number of the device PCRs
-		 * so we have to calculate them based on that
-		 */
-		u32 hash_offset = offsetof(struct tpml_pcr_selection, selection) +
-			i * offsetof(struct tpms_pcr_selection, pcr_select) +
-			i * ((num_pcr + 7) / 8);
-		u32 size_select_offset =
-			hash_offset + offsetof(struct tpms_pcr_selection,
-					       size_of_select);
-		u32 pcr_select_offset =
-			hash_offset + offsetof(struct tpms_pcr_selection,
-					       pcr_select);
-
-		pcrs.selection[i].hash =
-			get_unaligned_be16(response + hash_offset);
-		pcrs.selection[i].size_of_select =
-			__get_unaligned_be(response + size_select_offset);
-		if (pcrs.selection[i].size_of_select > TPM2_PCR_SELECT_MAX)
-			goto out;
-		/* copy the array of pcr_select */
-		memcpy(pcrs.selection[i].pcr_select, response + pcr_select_offset,
-		       pcrs.selection[i].size_of_select);
-	}
-
-	for (i = 0; i < pcrs.count; i++) {
-		u32 hash_mask = alg_to_mask(pcrs.selection[i].hash);
-
-		if (hash_mask) {
-			*supported_pcr |= hash_mask;
-			if (is_active_pcr(&pcrs.selection[i]))
-				*active_pcr |= hash_mask;
-		} else {
-			EFI_PRINT("Unknown algorithm %x\n", pcrs.selection[i].hash);
-		}
-	}
-
-	*pcr_banks = pcrs.count;
-
-	return 0;
-out:
-	return -1;
-}
-
-/**
- * __get_active_pcr_banks() - returns the currently active PCR banks
- *
- * @active_pcr_banks:		pointer for receiving the bitmap of currently
- *				active PCR banks
- *
- * Return:	status code
- */
-static efi_status_t __get_active_pcr_banks(u32 *active_pcr_banks)
-{
-	struct udevice *dev;
-	u32 active = 0, supported = 0, pcr_banks = 0;
-	efi_status_t ret;
-	int err;
-
-	ret = platform_get_tpm2_device(&dev);
-	if (ret != EFI_SUCCESS)
-		goto out;
-
-	err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_banks);
-	if (err) {
-		ret = EFI_DEVICE_ERROR;
-		goto out;
-	}
-
-	*active_pcr_banks = active;
-
-out:
-	return ret;
-}
-
-/* tcg2_create_digest - create a list of digests of the supported PCR banks
- *			for a given memory range
- *
- * @input:		input memory
- * @length:		length of buffer to calculate the digest
- * @digest_list:	list of digests to fill in
- *
- * Return:		status code
- */
-static efi_status_t tcg2_create_digest(const u8 *input, u32 length,
-				       struct tpml_digest_values *digest_list)
-{
-	sha1_context ctx;
-	sha256_context ctx_256;
-	sha512_context ctx_512;
-	u8 final[TPM2_SHA512_DIGEST_SIZE];
-	efi_status_t ret;
-	u32 active;
-	size_t i;
-
-	ret = __get_active_pcr_banks(&active);
-	if (ret != EFI_SUCCESS)
-		return ret;
-
-	digest_list->count = 0;
-	for (i = 0; i < MAX_HASH_COUNT; i++) {
-		u16 hash_alg = hash_algo_list[i].hash_alg;
-
-		if (!(active & alg_to_mask(hash_alg)))
-			continue;
-		switch (hash_alg) {
-		case TPM2_ALG_SHA1:
-			sha1_starts(&ctx);
-			sha1_update(&ctx, input, length);
-			sha1_finish(&ctx, final);
-			break;
-		case TPM2_ALG_SHA256:
-			sha256_starts(&ctx_256);
-			sha256_update(&ctx_256, input, length);
-			sha256_finish(&ctx_256, final);
-			break;
-		case TPM2_ALG_SHA384:
-			sha384_starts(&ctx_512);
-			sha384_update(&ctx_512, input, length);
-			sha384_finish(&ctx_512, final);
-			break;
-		case TPM2_ALG_SHA512:
-			sha512_starts(&ctx_512);
-			sha512_update(&ctx_512, input, length);
-			sha512_finish(&ctx_512, final);
-			break;
-		default:
-			EFI_PRINT("Unsupported algorithm %x\n", hash_alg);
-			return EFI_INVALID_PARAMETER;
-		}
-		digest_list->digests[digest_list->count].hash_alg = hash_alg;
-		memcpy(&digest_list->digests[digest_list->count].digest, final,
-		       (u32)alg_to_len(hash_alg));
-		digest_list->count++;
-	}
-
-	return EFI_SUCCESS;
-}
-
 /**
  * efi_tcg2_get_capability() - protocol capability information and state information
  *
@@ -759,7 +258,7 @@ efi_tcg2_get_capability(struct efi_tcg2_protocol *this,
 	capability->protocol_version.major = 1;
 	capability->protocol_version.minor = 1;
 
-	efi_ret = platform_get_tpm2_device(&dev);
+	efi_ret = tcg2_platform_get_tpm2(&dev);
 	if (efi_ret != EFI_SUCCESS) {
 		capability->supported_event_logs = 0;
 		capability->hash_algorithm_bitmap = 0;
@@ -855,7 +354,7 @@ efi_tcg2_get_eventlog(struct efi_tcg2_protocol *this,
 		goto out;
 	}
 
-	ret = platform_get_tpm2_device(&dev);
+	ret = tcg2_platform_get_tpm2(&dev);
 	if (ret != EFI_SUCCESS) {
 		event_log_location = NULL;
 		event_log_last_entry = NULL;
@@ -890,6 +389,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
 	struct efi_image_regions *regs = NULL;
 	void *new_efi = NULL;
 	u8 hash[TPM2_SHA512_DIGEST_SIZE];
+	struct udevice *dev;
 	efi_status_t ret;
 	u32 active;
 	int i;
@@ -905,16 +405,20 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
 		goto out;
 	}
 
-	ret = __get_active_pcr_banks(&active);
+	ret = tcg2_platform_get_tpm2(&dev);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
+	ret = tcg2_get_active_pcr_banks(dev, &active);
 	if (ret != EFI_SUCCESS) {
 		goto out;
 	}
 
 	digest_list->count = 0;
-	for (i = 0; i < MAX_HASH_COUNT; i++) {
-		u16 hash_alg = hash_algo_list[i].hash_alg;
+	for (i = 0; i < ARRAY_SIZE(tpm2_supported_algorithms); i++) {
+		u16 hash_alg = tpm2_supported_algorithms[i];
 
-		if (!(active & alg_to_mask(hash_alg)))
+		if (!(active & tpm2_algorithm_to_mask(hash_alg)))
 			continue;
 		switch (hash_alg) {
 		case TPM2_ALG_SHA1:
@@ -935,7 +439,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
 		}
 		digest_list->digests[digest_list->count].hash_alg = hash_alg;
 		memcpy(&digest_list->digests[digest_list->count].digest, hash,
-		       (u32)alg_to_len(hash_alg));
+		       (u32)tpm2_algorithm_to_len(hash_alg));
 		digest_list->count++;
 	}
 
@@ -975,7 +479,7 @@ efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size,
 	if (!is_tcg2_protocol_installed())
 		return EFI_SUCCESS;
 
-	ret = platform_get_tpm2_device(&dev);
+	ret = tcg2_platform_get_tpm2(&dev);
 	if (ret != EFI_SUCCESS)
 		return EFI_SECURITY_VIOLATION;
 
@@ -1084,7 +588,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
 		goto out;
 	}
 
-	ret = platform_get_tpm2_device(&dev);
+	ret = tcg2_platform_get_tpm2(&dev);
 	if (ret != EFI_SUCCESS)
 		goto out;
 
@@ -1119,7 +623,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
 		ret = tcg2_hash_pe_image((void *)(uintptr_t)data_to_hash,
 					 data_to_hash_len, &digest_list);
 	} else {
-		ret = tcg2_create_digest((u8 *)(uintptr_t)data_to_hash,
+		ret = tcg2_create_digest(dev, (u8 *)(uintptr_t)data_to_hash,
 					 data_to_hash_len, &digest_list);
 	}
 
@@ -1182,7 +686,7 @@ efi_tcg2_submit_command(struct efi_tcg2_protocol *this,
 		goto out;
 	}
 
-	ret = platform_get_tpm2_device(&dev);
+	ret = tcg2_platform_get_tpm2(&dev);
 	if (ret != EFI_SUCCESS)
 		goto out;
 
@@ -1211,6 +715,7 @@ static efi_status_t EFIAPI
 efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
 			      u32 *active_pcr_banks)
 {
+	struct udevice *dev;
 	efi_status_t ret;
 
 	if (!this || !active_pcr_banks) {
@@ -1218,8 +723,12 @@ efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
 		goto out;
 	}
 
+	ret = tcg2_platform_get_tpm2(&dev);
+	if (ret != EFI_SUCCESS)
+		goto out;
+
 	EFI_ENTRY("%p, %p", this, active_pcr_banks);
-	ret = __get_active_pcr_banks(active_pcr_banks);
+	ret = tcg2_get_active_pcr_banks(dev, active_pcr_banks);
 
 out:
 	return EFI_EXIT(ret);
@@ -1270,397 +779,6 @@ static const struct efi_tcg2_protocol efi_tcg2_protocol = {
 	.get_result_of_set_active_pcr_banks = efi_tcg2_get_result_of_set_active_pcr_banks,
 };
 
-/**
- * parse_event_log_header() -  Parse and verify the event log header fields
- *
- * @buffer:			Pointer to the start of the eventlog
- * @size:			Size of the eventlog
- * @pos:			Return offset of the next event in buffer right
- *				after the event header i.e specID
- *
- * Return:	status code
- */
-static efi_status_t parse_event_log_header(void *buffer, u32 size, u32 *pos)
-{
-	struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-	int i = 0;
-
-	if (size < sizeof(*event_header))
-		return EFI_COMPROMISED_DATA;
-
-	if (get_unaligned_le32(&event_header->pcr_index) != 0 ||
-	    get_unaligned_le32(&event_header->event_type) != EV_NO_ACTION)
-		return EFI_COMPROMISED_DATA;
-
-	for (i = 0; i < sizeof(event_header->digest); i++) {
-		if (event_header->digest[i])
-			return EFI_COMPROMISED_DATA;
-	}
-
-	*pos += sizeof(*event_header);
-
-	return EFI_SUCCESS;
-}
-
-/**
- * parse_specid_event() -  Parse and verify the specID Event in the eventlog
- *
- * @dev:		udevice
- * @buffer:		Pointer to the start of the eventlog
- * @log_size:		Size of the eventlog
- * @pos:		[in] Offset of specID event in the eventlog buffer
- *			[out] Return offset of the next event in the buffer
- *			after the specID
- * @digest_list:	list of digests in the event
- *
- * Return:		status code
- * @pos			Offset in the eventlog where the specID event ends
- * @digest_list:	list of digests in the event
- */
-static efi_status_t parse_specid_event(struct udevice *dev, void *buffer,
-				       u32 log_size, u32 *pos,
-				       struct tpml_digest_values *digest_list)
-{
-	struct tcg_efi_spec_id_event *spec_event;
-	struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-	size_t spec_event_size;
-	u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-	u32 spec_active = 0;
-	u16 hash_alg;
-	u8 vendor_sz;
-	int err, i;
-
-	if (*pos >= log_size || (*pos + sizeof(*spec_event)) > log_size)
-		return EFI_COMPROMISED_DATA;
-
-	/* Check specID event data */
-	spec_event = (struct tcg_efi_spec_id_event *)((uintptr_t)buffer + *pos);
-	/* Check for signature */
-	if (memcmp(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-		   sizeof(TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03))) {
-		log_err("specID Event: Signature mismatch\n");
-		return EFI_COMPROMISED_DATA;
-	}
-
-	if (spec_event->spec_version_minor !=
-			TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2 ||
-	    spec_event->spec_version_major !=
-			TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2)
-		return EFI_COMPROMISED_DATA;
-
-	if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-	    spec_event->number_of_algorithms < 1) {
-		log_err("specID Event: Number of algorithms incorrect\n");
-		return EFI_COMPROMISED_DATA;
-	}
-
-	alg_count = spec_event->number_of_algorithms;
-
-	err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-	if (err)
-		return EFI_DEVICE_ERROR;
-
-	digest_list->count = 0;
-	/*
-	 * We have to take care that the sequence of algorithms that we record
-	 * in digest_list matches the sequence in eventlog.
-	 */
-	for (i = 0; i < alg_count; i++) {
-		hash_alg =
-		  get_unaligned_le16(&spec_event->digest_sizes[i].algorithm_id);
-
-		if (!(supported & alg_to_mask(hash_alg))) {
-			log_err("specID Event: Unsupported algorithm\n");
-			return EFI_COMPROMISED_DATA;
-		}
-		digest_list->digests[digest_list->count++].hash_alg = hash_alg;
-
-		spec_active |= alg_to_mask(hash_alg);
-	}
-
-	/*
-	 * TCG specification expects the event log to have hashes for all
-	 * active PCR's
-	 */
-	if (spec_active != active) {
-		/*
-		 * Previous stage bootloader should know all the active PCR's
-		 * and use them in the Eventlog.
-		 */
-		log_err("specID Event: All active hash alg not present\n");
-		return EFI_COMPROMISED_DATA;
-	}
-
-	/*
-	 * the size of the spec event and placement of vendor_info_size
-	 * depends on supported algoriths
-	 */
-	spec_event_size =
-		offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-		alg_count * sizeof(spec_event->digest_sizes[0]);
-
-	if (*pos + spec_event_size >= log_size)
-		return EFI_COMPROMISED_DATA;
-
-	vendor_sz = *(uint8_t *)((uintptr_t)buffer + *pos + spec_event_size);
-
-	spec_event_size += sizeof(vendor_sz) + vendor_sz;
-	*pos += spec_event_size;
-
-	if (get_unaligned_le32(&event_header->event_size) != spec_event_size) {
-		log_err("specID event: header event size mismatch\n");
-		/* Right way to handle this can be to call SetActive PCR's */
-		return EFI_COMPROMISED_DATA;
-	}
-
-	return EFI_SUCCESS;
-}
-
-/**
- * tcg2_parse_event() -  Parse the event in the eventlog
- *
- * @dev:		udevice
- * @buffer:		Pointer to the start of the eventlog
- * @log_size:		Size of the eventlog
- * @offset:		[in] Offset of the event in the eventlog buffer
- *			[out] Return offset of the next event in the buffer
- * @digest_list:	list of digests in the event
- * @pcr			Index of the PCR in the event
- *
- * Return:		status code
- */
-static efi_status_t tcg2_parse_event(struct udevice *dev, void *buffer,
-				     u32 log_size, u32 *offset,
-				     struct tpml_digest_values *digest_list,
-				     u32 *pcr)
-{
-	struct tcg_pcr_event2 *event = NULL;
-	u32 count, size, event_size;
-	size_t pos;
-
-	event_size = tcg_event_final_size(digest_list);
-	if (*offset >= log_size || *offset + event_size > log_size) {
-		log_err("Event exceeds log size\n");
-		return EFI_COMPROMISED_DATA;
-	}
-
-	event = (struct tcg_pcr_event2 *)((uintptr_t)buffer + *offset);
-	*pcr = get_unaligned_le32(&event->pcr_index);
-
-	/* get the count */
-	count = get_unaligned_le32(&event->digests.count);
-	if (count != digest_list->count)
-		return EFI_COMPROMISED_DATA;
-
-	pos = offsetof(struct tcg_pcr_event2, digests);
-	pos += offsetof(struct tpml_digest_values, digests);
-
-	for (int i = 0; i < digest_list->count; i++) {
-		u16 alg;
-		u16 hash_alg = digest_list->digests[i].hash_alg;
-		u8 *digest = (u8 *)&digest_list->digests[i].digest;
-
-		alg = get_unaligned_le16((void *)((uintptr_t)event + pos));
-
-		if (alg != hash_alg)
-			return EFI_COMPROMISED_DATA;
-
-		pos += offsetof(struct tpmt_ha, digest);
-		memcpy(digest, (void *)((uintptr_t)event + pos), alg_to_len(hash_alg));
-		pos += alg_to_len(hash_alg);
-	}
-
-	size = get_unaligned_le32((void *)((uintptr_t)event + pos));
-	event_size += size;
-	pos += sizeof(u32); /* tcg_pcr_event2 event_size*/
-	pos += size;
-
-	/* make sure the calculated buffer is what we checked against */
-	if (pos != event_size)
-		return EFI_COMPROMISED_DATA;
-
-	if (pos > log_size)
-		return EFI_COMPROMISED_DATA;
-
-	*offset += pos;
-
-	return EFI_SUCCESS;
-}
-
-/**
- * tcg2_get_fw_eventlog() -  Get the eventlog address and size
- *
- * If the previous firmware has passed some eventlog, this function get it's
- * location and check for it's validity.
- *
- * @dev:		udevice
- * @log_buffer:		eventlog address
- * @log_sz:		eventlog size
- *
- * Return:	status code
- */
-static efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer,
-					 size_t *log_sz)
-{
-	struct tpml_digest_values digest_list;
-	void *buffer;
-	efi_status_t ret;
-	u32 pcr, pos;
-	u64 base;
-	u32 sz;
-	bool extend_pcr = false;
-	int i;
-
-	ret = platform_get_eventlog(dev, &base, &sz);
-	if (ret != EFI_SUCCESS)
-		return ret;
-
-	if (sz > TPM2_EVENT_LOG_SIZE)
-		return EFI_VOLUME_FULL;
-
-	buffer = (void *)(uintptr_t)base;
-	pos = 0;
-	/* Parse the eventlog to check for its validity */
-	ret = parse_event_log_header(buffer, sz, &pos);
-	if (ret)
-		return ret;
-
-	ret = parse_specid_event(dev, buffer, sz, &pos, &digest_list);
-	if (ret) {
-		log_err("Error parsing SPEC ID Event\n");
-		return ret;
-	}
-
-	ret = tcg2_pcr_read(dev, 0, &digest_list);
-	if (ret) {
-		log_err("Error reading PCR 0\n");
-		return ret;
-	}
-
-	/*
-	 * If PCR0 is 0, previous firmware didn't have the capability
-	 * to extend the PCR. In this scenario, extend the PCR as
-	 * the eventlog is parsed.
-	 */
-	for (i = 0; i < digest_list.count; i++) {
-		u8 hash_buf[TPM2_SHA512_DIGEST_SIZE] = { 0 };
-		u16 hash_alg = digest_list.digests[i].hash_alg;
-
-		if (!memcmp((u8 *)&digest_list.digests[i].digest, hash_buf,
-			    alg_to_len(hash_alg)))
-			extend_pcr = true;
-	}
-
-	while (pos < sz) {
-		ret = tcg2_parse_event(dev, buffer, sz, &pos, &digest_list,
-				       &pcr);
-		if (ret) {
-			log_err("Error parsing event\n");
-			return ret;
-		}
-		if (extend_pcr) {
-			ret = tcg2_pcr_extend(dev, pcr, &digest_list);
-			if (ret != EFI_SUCCESS) {
-				log_err("Error in extending PCR\n");
-				return ret;
-			}
-
-			/* Clear the digest for next event */
-			for (i = 0; i < digest_list.count; i++) {
-				u16 hash_alg = digest_list.digests[i].hash_alg;
-				u8 *digest =
-				   (u8 *)&digest_list.digests[i].digest;
-
-				memset(digest, 0, alg_to_len(hash_alg));
-			}
-		}
-	}
-
-	memcpy(log_buffer, buffer, sz);
-	*log_sz = sz;
-
-	return ret;
-}
-
-/**
- * create_specid_event() - Create the first event in the eventlog
- *
- * @dev:			tpm device
- * @event_header:		Pointer to the final event header
- * @event_size:			final spec event size
- *
- * Return:	status code
- */
-static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
-					size_t *event_size)
-{
-	struct tcg_efi_spec_id_event *spec_event;
-	size_t spec_event_size;
-	efi_status_t ret = EFI_DEVICE_ERROR;
-	u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-	int err;
-	size_t i;
-
-	/*
-	 * Create Spec event. This needs to be the first event in the log
-	 * according to the TCG EFI protocol spec
-	 */
-
-	/* Setup specID event data */
-	spec_event = (struct tcg_efi_spec_id_event *)buffer;
-	memcpy(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-	       sizeof(spec_event->signature));
-	put_unaligned_le32(0, &spec_event->platform_class); /* type client */
-	spec_event->spec_version_minor =
-		TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2;
-	spec_event->spec_version_major =
-		TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2;
-	spec_event->spec_errata =
-		TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_ERRATA_TPM2;
-	spec_event->uintn_size = sizeof(efi_uintn_t) / sizeof(u32);
-
-	err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-
-	if (err)
-		goto out;
-
-	for (i = 0; i < pcr_count; i++) {
-		u16 hash_alg = hash_algo_list[i].hash_alg;
-		u16 hash_len = hash_algo_list[i].hash_len;
-
-		if (active & alg_to_mask(hash_alg)) {
-			put_unaligned_le16(hash_alg,
-					   &spec_event->digest_sizes[alg_count].algorithm_id);
-			put_unaligned_le16(hash_len,
-					   &spec_event->digest_sizes[alg_count].digest_size);
-			alg_count++;
-		}
-	}
-
-	spec_event->number_of_algorithms = alg_count;
-	if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-	    spec_event->number_of_algorithms < 1)
-		goto out;
-
-	/*
-	 * the size of the spec event and placement of vendor_info_size
-	 * depends on supported algoriths
-	 */
-	spec_event_size =
-		offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-		spec_event->number_of_algorithms * sizeof(spec_event->digest_sizes[0]);
-	/* no vendor info for us */
-	memset(buffer + spec_event_size, 0, 1);
-	/* add a byte for vendor_info_size in the spec event */
-	spec_event_size += 1;
-	*event_size = spec_event_size;
-
-	return EFI_SUCCESS;
-
-out:
-	return ret;
-}
-
 /**
  * tcg2_uninit - remove the final event table and free efi memory on failures
  */
@@ -1722,7 +840,7 @@ out:
 }
 
 /**
- * tcg2_measure_event() - common function to add event log and extend PCR
+ * measure_event() - common function to add event log and extend PCR
  *
  * @dev:		TPM device
  * @pcr_index:		PCR index
@@ -1732,14 +850,13 @@ out:
  *
  * Return:	status code
  */
-static efi_status_t
-tcg2_measure_event(struct udevice *dev, u32 pcr_index, u32 event_type,
-		   u32 size, u8 event[])
+static efi_status_t measure_event(struct udevice *dev, u32 pcr_index,
+				  u32 event_type, u32 size, u8 event[])
 {
 	struct tpml_digest_values digest_list;
 	efi_status_t ret;
 
-	ret = tcg2_create_digest(event, size, &digest_list);
+	ret = tcg2_create_digest(dev, event, size, &digest_list);
 	if (ret != EFI_SUCCESS)
 		goto out;
 
@@ -1766,9 +883,8 @@ static efi_status_t efi_append_scrtm_version(struct udevice *dev)
 {
 	efi_status_t ret;
 
-	ret = tcg2_measure_event(dev, 0, EV_S_CRTM_VERSION,
-				 strlen(version_string) + 1,
-				 (u8 *)version_string);
+	ret = measure_event(dev, 0, EV_S_CRTM_VERSION,
+			    strlen(version_string) + 1, (u8 *)version_string);
 
 	return ret;
 }
@@ -1784,12 +900,11 @@ static efi_status_t efi_init_event_log(void)
 	 * vendor_info_size is currently set to 0, we need to change the length
 	 * and allocate the flexible array member if this changes
 	 */
-	struct tcg_pcr_event *event_header = NULL;
+	struct tcg2_event_log elog;
 	struct udevice *dev;
-	size_t spec_event_size;
 	efi_status_t ret;
 
-	ret = platform_get_tpm2_device(&dev);
+	ret = tcg2_platform_get_tpm2(&dev);
 	if (ret != EFI_SUCCESS)
 		return ret;
 
@@ -1808,7 +923,6 @@ static efi_status_t efi_init_event_log(void)
 	 * The log header is defined to be in SHA1 event log entry format.
 	 * Setup event header
 	 */
-	event_header =  (struct tcg_pcr_event *)event_log.buffer;
 	event_log.pos = 0;
 	event_log.last_event_size = 0;
 	event_log.get_event_called = false;

lib/efi_loader/efi_tcg2.c static efi_status_t efi_init_event_log(void) · line 938

Quoted 7 lines
lib/efi_loader/efi_tcg2.c +3 -1
@@ -1819,34 +933,19 @@ static efi_status_t efi_init_event_log(void)
 	 * Check if earlier firmware have passed any eventlog. Different
 	 * platforms can use different ways to do so.
 	 */
-	ret = tcg2_get_fw_eventlog(dev, event_log.buffer, &event_log.pos);
+	ret = tcg2_init_log(dev, &elog);
+	if (ret != EFI_SUCCESS)
+		goto free_pool;

So I think this is the last bit we need to change in order to support EFI properly. I read the email regarding the newly added reserved memory memory to the TPM node and it's fine, but that won't work for the existing U-Boot dtbs. Since this was working out of the box, I'd still prefer to keep that working even if that entry is missing.

If you look at this function, there is an efi_allocate_pool() call a few lines above. What this does is allocate the EventLog memory for EFI. Note here that this *has* to be EFI memory since the kernel's efi-stub can still call into the firmware (and in fact it does, that's who we measure the initrd in > 5.18 kernels). After the allocation it looks for those DT entries, and if tpm_event_log_addr is found it parses the EventLog and
1. Extends the PCRs
2. Adds the events into the Eventlog

The reason for that is that TF-A (the Arm first stage boot loader), doesn't have any TPM drivers. So U-Boot is trying to be 'smart' here. We are grabbing the EventLog from the previous bootloader and if PCR0!=0 we replay that into the hardware and re-create the EventLog.

[...]

Thanks!
/Ilias

Quoted 1 line
#5 lore raw
Quoted 913 lines · Ilias Apalodimas

Hi Eddie,

        final_event->number_of_events++;
Quoted 886 lines
lib/efi_loader/efi_tcg2.c +30 -708
@@ -350,66 +142,6 @@ static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
      return ret;
 }
 
-/**
- * platform_get_tpm_device() - retrieve TPM device
- *
- * This function retrieves the udevice implementing a TPM
- *
- * This function may be overridden if special initialization is needed.
- *
- * @dev:     udevice
- * Return:   status code
- */
-__weak efi_status_t platform_get_tpm2_device(struct udevice **dev)
-{
-     for_each_tpm_device(*dev) {
-             /* Only support TPMv2 devices */
-             if (tpm_get_version(*dev) == TPM_V2)
-                     return EFI_SUCCESS;
-     }
-
-     return EFI_NOT_FOUND;
-}
-
-/**
- * platform_get_eventlog() - retrieve the eventlog address and size
- *
- * This function retrieves the eventlog address and size if the underlying
- * firmware has done some measurements and passed them.
- *
- * This function may be overridden based on platform specific method of
- * passing the eventlog address and size.
- *
- * @dev:     udevice
- * @addr:    eventlog address
- * @sz:              eventlog size
- * Return:   status code
- */
-__weak efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr,
-                                       u32 *sz)
-{
-     const u64 *basep;
-     const u32 *sizep;
-
-     basep = dev_read_prop(dev, "tpm_event_log_addr", NULL);
-     if (!basep)
-             return EFI_NOT_FOUND;
-
-     *addr = be64_to_cpup((__force __be64 *)basep);
-
-     sizep = dev_read_prop(dev, "tpm_event_log_size", NULL);
-     if (!sizep)
-             return EFI_NOT_FOUND;
-
-     *sz = be32_to_cpup((__force __be32 *)sizep);
-     if (*sz == 0) {
-             log_debug("event log empty\n");
-             return EFI_NOT_FOUND;
-     }
-
-     return EFI_SUCCESS;
-}
-
 /**
  * tpm2_get_max_command_size() - get the supported max command size
  *
@@ -485,239 +217,6 @@ static int tpm2_get_manufacturer_id(struct udevice *dev, u32 *manufacturer_id)
      return 0;
 }
 
-/**
- * tpm2_get_num_pcr() - get the number of PCRs
- *
- * @dev:             TPM device
- * @manufacturer_id: output buffer for the number
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_num_pcr(struct udevice *dev, u32 *num_pcr)
-{
-     u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-     u32 ret;
-
-     memset(response, 0, sizeof(response));
-     ret = tpm2_get_capability(dev, TPM2_CAP_TPM_PROPERTIES,
-                               TPM2_PT_PCR_COUNT, response, 1);
-     if (ret)
-             return -1;
-
-     *num_pcr = get_unaligned_be32(response + properties_offset);
-     if (*num_pcr > TPM2_MAX_PCRS)
-             return -1;
-
-     return 0;
-}
-
-/**
- * is_active_pcr() - Check if a supported algorithm is active
- *
- * @dev:             TPM device
- * @selection:               struct of PCR information
- *
- * Return: true if PCR is active
- */
-static bool is_active_pcr(struct tpms_pcr_selection *selection)
-{
-     int i;
-     /*
-      * check the pcr_select. If at least one of the PCRs supports the
-      * algorithm add it on the active ones
-      */
-     for (i = 0; i < selection->size_of_select; i++) {
-             if (selection->pcr_select[i])
-                     return true;
-     }
-
-     return false;
-}
-
-/**
- * tpm2_get_pcr_info() - get the supported, active PCRs and number of banks
- *
- * @dev:             TPM device
- * @supported_pcr:   bitmask with the algorithms supported
- * @active_pcr:              bitmask with the active algorithms
- * @pcr_banks:               number of PCR banks
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_pcr_info(struct udevice *dev, u32 *supported_pcr,
-                          u32 *active_pcr, u32 *pcr_banks)
-{
-     u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-     struct tpml_pcr_selection pcrs;
-     u32 ret, num_pcr;
-     size_t i;
-     int tpm_ret;
-
-     *supported_pcr = 0;
-     *active_pcr = 0;
-     *pcr_banks = 0;
-     memset(response, 0, sizeof(response));
-     ret = tpm2_get_capability(dev, TPM2_CAP_PCRS, 0, response, 1);
-     if (ret)
-             goto out;
-
-     pcrs.count = get_unaligned_be32(response);
-     /*
-      * We only support 5 algorithms for now so check against that
-      * instead of TPM2_NUM_PCR_BANKS
-      */
-     if (pcrs.count > MAX_HASH_COUNT || pcrs.count < 1)
-             goto out;
-
-     tpm_ret = tpm2_get_num_pcr(dev, &num_pcr);
-     if (tpm_ret)
-             goto out;
-
-     for (i = 0; i < pcrs.count; i++) {
-             /*
-              * Definition of TPMS_PCR_SELECTION Structure
-              * hash: u16
-              * size_of_select: u8
-              * pcr_select: u8 array
-              *
-              * The offsets depend on the number of the device PCRs
-              * so we have to calculate them based on that
-              */
-             u32 hash_offset = offsetof(struct tpml_pcr_selection, selection) +
-                     i * offsetof(struct tpms_pcr_selection, pcr_select) +
-                     i * ((num_pcr + 7) / 8);
-             u32 size_select_offset =
-                     hash_offset + offsetof(struct tpms_pcr_selection,
-                                            size_of_select);
-             u32 pcr_select_offset =
-                     hash_offset + offsetof(struct tpms_pcr_selection,
-                                            pcr_select);
-
-             pcrs.selection[i].hash =
-                     get_unaligned_be16(response + hash_offset);
-             pcrs.selection[i].size_of_select =
-                     __get_unaligned_be(response + size_select_offset);
-             if (pcrs.selection[i].size_of_select > TPM2_PCR_SELECT_MAX)
-                     goto out;
-             /* copy the array of pcr_select */
-             memcpy(pcrs.selection[i].pcr_select, response + pcr_select_offset,
-                    pcrs.selection[i].size_of_select);
-     }
-
-     for (i = 0; i < pcrs.count; i++) {
-             u32 hash_mask = alg_to_mask(pcrs.selection[i].hash);
-
-             if (hash_mask) {
-                     *supported_pcr |= hash_mask;
-                     if (is_active_pcr(&pcrs.selection[i]))
-                             *active_pcr |= hash_mask;
-             } else {
-                     EFI_PRINT("Unknown algorithm %x\n", pcrs.selection[i].hash);
-             }
-     }
-
-     *pcr_banks = pcrs.count;
-
-     return 0;
-out:
-     return -1;
-}
-
-/**
- * __get_active_pcr_banks() - returns the currently active PCR banks
- *
- * @active_pcr_banks:                pointer for receiving the bitmap of currently
- *                           active PCR banks
- *
- * Return:   status code
- */
-static efi_status_t __get_active_pcr_banks(u32 *active_pcr_banks)
-{
-     struct udevice *dev;
-     u32 active = 0, supported = 0, pcr_banks = 0;
-     efi_status_t ret;
-     int err;
-
-     ret = platform_get_tpm2_device(&dev);
-     if (ret != EFI_SUCCESS)
-             goto out;
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_banks);
-     if (err) {
-             ret = EFI_DEVICE_ERROR;
-             goto out;
-     }
-
-     *active_pcr_banks = active;
-
-out:
-     return ret;
-}
-
-/* tcg2_create_digest - create a list of digests of the supported PCR banks
- *                   for a given memory range
- *
- * @input:           input memory
- * @length:          length of buffer to calculate the digest
- * @digest_list:     list of digests to fill in
- *
- * Return:           status code
- */
-static efi_status_t tcg2_create_digest(const u8 *input, u32 length,
-                                    struct tpml_digest_values *digest_list)
-{
-     sha1_context ctx;
-     sha256_context ctx_256;
-     sha512_context ctx_512;
-     u8 final[TPM2_SHA512_DIGEST_SIZE];
-     efi_status_t ret;
-     u32 active;
-     size_t i;
-
-     ret = __get_active_pcr_banks(&active);
-     if (ret != EFI_SUCCESS)
-             return ret;
-
-     digest_list->count = 0;
-     for (i = 0; i < MAX_HASH_COUNT; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
-
-             if (!(active & alg_to_mask(hash_alg)))
-                     continue;
-             switch (hash_alg) {
-             case TPM2_ALG_SHA1:
-                     sha1_starts(&ctx);
-                     sha1_update(&ctx, input, length);
-                     sha1_finish(&ctx, final);
-                     break;
-             case TPM2_ALG_SHA256:
-                     sha256_starts(&ctx_256);
-                     sha256_update(&ctx_256, input, length);
-                     sha256_finish(&ctx_256, final);
-                     break;
-             case TPM2_ALG_SHA384:
-                     sha384_starts(&ctx_512);
-                     sha384_update(&ctx_512, input, length);
-                     sha384_finish(&ctx_512, final);
-                     break;
-             case TPM2_ALG_SHA512:
-                     sha512_starts(&ctx_512);
-                     sha512_update(&ctx_512, input, length);
-                     sha512_finish(&ctx_512, final);
-                     break;
-             default:
-                     EFI_PRINT("Unsupported algorithm %x\n", hash_alg);
-                     return EFI_INVALID_PARAMETER;
-             }
-             digest_list->digests[digest_list->count].hash_alg = hash_alg;
-             memcpy(&digest_list->digests[digest_list->count].digest, final,
-                    (u32)alg_to_len(hash_alg));
-             digest_list->count++;
-     }
-
-     return EFI_SUCCESS;
-}
-
 /**
  * efi_tcg2_get_capability() - protocol capability information and state information
  *
@@ -759,7 +258,7 @@ efi_tcg2_get_capability(struct efi_tcg2_protocol *this,
      capability->protocol_version.major = 1;
      capability->protocol_version.minor = 1;
 
-     efi_ret = platform_get_tpm2_device(&dev);
+     efi_ret = tcg2_platform_get_tpm2(&dev);
      if (efi_ret != EFI_SUCCESS) {
              capability->supported_event_logs = 0;
              capability->hash_algorithm_bitmap = 0;
@@ -855,7 +354,7 @@ efi_tcg2_get_eventlog(struct efi_tcg2_protocol *this,
              goto out;
      }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS) {
              event_log_location = NULL;
              event_log_last_entry = NULL;
@@ -890,6 +389,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
      struct efi_image_regions *regs = NULL;
      void *new_efi = NULL;
      u8 hash[TPM2_SHA512_DIGEST_SIZE];
+     struct udevice *dev;
      efi_status_t ret;
      u32 active;
      int i;
@@ -905,16 +405,20 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
              goto out;
      }
 
-     ret = __get_active_pcr_banks(&active);
+     ret = tcg2_platform_get_tpm2(&dev);
+     if (ret != EFI_SUCCESS)
+             goto out;
+
+     ret = tcg2_get_active_pcr_banks(dev, &active);
      if (ret != EFI_SUCCESS) {
              goto out;
      }
 
      digest_list->count = 0;
-     for (i = 0; i < MAX_HASH_COUNT; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
+     for (i = 0; i < ARRAY_SIZE(tpm2_supported_algorithms); i++) {
+             u16 hash_alg = tpm2_supported_algorithms[i];
 
-             if (!(active & alg_to_mask(hash_alg)))
+             if (!(active & tpm2_algorithm_to_mask(hash_alg)))
                      continue;
              switch (hash_alg) {
              case TPM2_ALG_SHA1:
@@ -935,7 +439,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
              }
              digest_list->digests[digest_list->count].hash_alg = hash_alg;
              memcpy(&digest_list->digests[digest_list->count].digest, hash,
-                    (u32)alg_to_len(hash_alg));
+                    (u32)tpm2_algorithm_to_len(hash_alg));
              digest_list->count++;
      }
 
@@ -975,7 +479,7 @@ efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size,
      if (!is_tcg2_protocol_installed())
              return EFI_SUCCESS;
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              return EFI_SECURITY_VIOLATION;
 
@@ -1084,7 +588,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
              goto out;
      }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              goto out;
 
@@ -1119,7 +623,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
              ret = tcg2_hash_pe_image((void *)(uintptr_t)data_to_hash,
                                       data_to_hash_len, &digest_list);
      } else {
-             ret = tcg2_create_digest((u8 *)(uintptr_t)data_to_hash,
+             ret = tcg2_create_digest(dev, (u8 *)(uintptr_t)data_to_hash,
                                       data_to_hash_len, &digest_list);
      }
 
@@ -1182,7 +686,7 @@ efi_tcg2_submit_command(struct efi_tcg2_protocol *this,
              goto out;
      }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              goto out;
 
@@ -1211,6 +715,7 @@ static efi_status_t EFIAPI
 efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
                            u32 *active_pcr_banks)
 {
+     struct udevice *dev;
      efi_status_t ret;
 
      if (!this || !active_pcr_banks) {
@@ -1218,8 +723,12 @@ efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
              goto out;
      }
 
+     ret = tcg2_platform_get_tpm2(&dev);
+     if (ret != EFI_SUCCESS)
+             goto out;
+
      EFI_ENTRY("%p, %p", this, active_pcr_banks);
-     ret = __get_active_pcr_banks(active_pcr_banks);
+     ret = tcg2_get_active_pcr_banks(dev, active_pcr_banks);
 
 out:
      return EFI_EXIT(ret);
@@ -1270,397 +779,6 @@ static const struct efi_tcg2_protocol efi_tcg2_protocol = {
      .get_result_of_set_active_pcr_banks = efi_tcg2_get_result_of_set_active_pcr_banks,
 };
 
-/**
- * parse_event_log_header() -  Parse and verify the event log header fields
- *
- * @buffer:                  Pointer to the start of the eventlog
- * @size:                    Size of the eventlog
- * @pos:                     Return offset of the next event in buffer right
- *                           after the event header i.e specID
- *
- * Return:   status code
- */
-static efi_status_t parse_event_log_header(void *buffer, u32 size, u32 *pos)
-{
-     struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-     int i = 0;
-
-     if (size < sizeof(*event_header))
-             return EFI_COMPROMISED_DATA;
-
-     if (get_unaligned_le32(&event_header->pcr_index) != 0 ||
-         get_unaligned_le32(&event_header->event_type) != EV_NO_ACTION)
-             return EFI_COMPROMISED_DATA;
-
-     for (i = 0; i < sizeof(event_header->digest); i++) {
-             if (event_header->digest[i])
-                     return EFI_COMPROMISED_DATA;
-     }
-
-     *pos += sizeof(*event_header);
-
-     return EFI_SUCCESS;
-}
-
-/**
- * parse_specid_event() -  Parse and verify the specID Event in the eventlog
- *
- * @dev:             udevice
- * @buffer:          Pointer to the start of the eventlog
- * @log_size:                Size of the eventlog
- * @pos:             [in] Offset of specID event in the eventlog buffer
- *                   [out] Return offset of the next event in the buffer
- *                   after the specID
- * @digest_list:     list of digests in the event
- *
- * Return:           status code
- * @pos                      Offset in the eventlog where the specID event ends
- * @digest_list:     list of digests in the event
- */
-static efi_status_t parse_specid_event(struct udevice *dev, void *buffer,
-                                    u32 log_size, u32 *pos,
-                                    struct tpml_digest_values *digest_list)
-{
-     struct tcg_efi_spec_id_event *spec_event;
-     struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-     size_t spec_event_size;
-     u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-     u32 spec_active = 0;
-     u16 hash_alg;
-     u8 vendor_sz;
-     int err, i;
-
-     if (*pos >= log_size || (*pos + sizeof(*spec_event)) > log_size)
-             return EFI_COMPROMISED_DATA;
-
-     /* Check specID event data */
-     spec_event = (struct tcg_efi_spec_id_event *)((uintptr_t)buffer + *pos);
-     /* Check for signature */
-     if (memcmp(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-                sizeof(TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03))) {
-             log_err("specID Event: Signature mismatch\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     if (spec_event->spec_version_minor !=
-                     TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2 ||
-         spec_event->spec_version_major !=
-                     TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2)
-             return EFI_COMPROMISED_DATA;
-
-     if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-         spec_event->number_of_algorithms < 1) {
-             log_err("specID Event: Number of algorithms incorrect\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     alg_count = spec_event->number_of_algorithms;
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-     if (err)
-             return EFI_DEVICE_ERROR;
-
-     digest_list->count = 0;
-     /*
-      * We have to take care that the sequence of algorithms that we record
-      * in digest_list matches the sequence in eventlog.
-      */
-     for (i = 0; i < alg_count; i++) {
-             hash_alg =
-               get_unaligned_le16(&spec_event->digest_sizes[i].algorithm_id);
-
-             if (!(supported & alg_to_mask(hash_alg))) {
-                     log_err("specID Event: Unsupported algorithm\n");
-                     return EFI_COMPROMISED_DATA;
-             }
-             digest_list->digests[digest_list->count++].hash_alg = hash_alg;
-
-             spec_active |= alg_to_mask(hash_alg);
-     }
-
-     /*
-      * TCG specification expects the event log to have hashes for all
-      * active PCR's
-      */
-     if (spec_active != active) {
-             /*
-              * Previous stage bootloader should know all the active PCR's
-              * and use them in the Eventlog.
-              */
-             log_err("specID Event: All active hash alg not present\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     /*
-      * the size of the spec event and placement of vendor_info_size
-      * depends on supported algoriths
-      */
-     spec_event_size =
-             offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-             alg_count * sizeof(spec_event->digest_sizes[0]);
-
-     if (*pos + spec_event_size >= log_size)
-             return EFI_COMPROMISED_DATA;
-
-     vendor_sz = *(uint8_t *)((uintptr_t)buffer + *pos + spec_event_size);
-
-     spec_event_size += sizeof(vendor_sz) + vendor_sz;
-     *pos += spec_event_size;
-
-     if (get_unaligned_le32(&event_header->event_size) != spec_event_size) {
-             log_err("specID event: header event size mismatch\n");
-             /* Right way to handle this can be to call SetActive PCR's */
-             return EFI_COMPROMISED_DATA;
-     }
-
-     return EFI_SUCCESS;
-}
-
-/**
- * tcg2_parse_event() -  Parse the event in the eventlog
- *
- * @dev:             udevice
- * @buffer:          Pointer to the start of the eventlog
- * @log_size:                Size of the eventlog
- * @offset:          [in] Offset of the event in the eventlog buffer
- *                   [out] Return offset of the next event in the buffer
- * @digest_list:     list of digests in the event
- * @pcr                      Index of the PCR in the event
- *
- * Return:           status code
- */
-static efi_status_t tcg2_parse_event(struct udevice *dev, void *buffer,
-                                  u32 log_size, u32 *offset,
-                                  struct tpml_digest_values *digest_list,
-                                  u32 *pcr)
-{
-     struct tcg_pcr_event2 *event = NULL;
-     u32 count, size, event_size;
-     size_t pos;
-
-     event_size = tcg_event_final_size(digest_list);
-     if (*offset >= log_size || *offset + event_size > log_size) {
-             log_err("Event exceeds log size\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     event = (struct tcg_pcr_event2 *)((uintptr_t)buffer + *offset);
-     *pcr = get_unaligned_le32(&event->pcr_index);
-
-     /* get the count */
-     count = get_unaligned_le32(&event->digests.count);
-     if (count != digest_list->count)
-             return EFI_COMPROMISED_DATA;
-
-     pos = offsetof(struct tcg_pcr_event2, digests);
-     pos += offsetof(struct tpml_digest_values, digests);
-
-     for (int i = 0; i < digest_list->count; i++) {
-             u16 alg;
-             u16 hash_alg = digest_list->digests[i].hash_alg;
-             u8 *digest = (u8 *)&digest_list->digests[i].digest;
-
-             alg = get_unaligned_le16((void *)((uintptr_t)event + pos));
-
-             if (alg != hash_alg)
-                     return EFI_COMPROMISED_DATA;
-
-             pos += offsetof(struct tpmt_ha, digest);
-             memcpy(digest, (void *)((uintptr_t)event + pos), alg_to_len(hash_alg));
-             pos += alg_to_len(hash_alg);
-     }
-
-     size = get_unaligned_le32((void *)((uintptr_t)event + pos));
-     event_size += size;
-     pos += sizeof(u32); /* tcg_pcr_event2 event_size*/
-     pos += size;
-
-     /* make sure the calculated buffer is what we checked against */
-     if (pos != event_size)
-             return EFI_COMPROMISED_DATA;
-
-     if (pos > log_size)
-             return EFI_COMPROMISED_DATA;
-
-     *offset += pos;
-
-     return EFI_SUCCESS;
-}
-
-/**
- * tcg2_get_fw_eventlog() -  Get the eventlog address and size
- *
- * If the previous firmware has passed some eventlog, this function get it's
- * location and check for it's validity.
- *
- * @dev:             udevice
- * @log_buffer:              eventlog address
- * @log_sz:          eventlog size
- *
- * Return:   status code
- */
-static efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer,
-                                      size_t *log_sz)
-{
-     struct tpml_digest_values digest_list;
-     void *buffer;
-     efi_status_t ret;
-     u32 pcr, pos;
-     u64 base;
-     u32 sz;
-     bool extend_pcr = false;
-     int i;
-
-     ret = platform_get_eventlog(dev, &base, &sz);
-     if (ret != EFI_SUCCESS)
-             return ret;
-
-     if (sz > TPM2_EVENT_LOG_SIZE)
-             return EFI_VOLUME_FULL;
-
-     buffer = (void *)(uintptr_t)base;
-     pos = 0;
-     /* Parse the eventlog to check for its validity */
-     ret = parse_event_log_header(buffer, sz, &pos);
-     if (ret)
-             return ret;
-
-     ret = parse_specid_event(dev, buffer, sz, &pos, &digest_list);
-     if (ret) {
-             log_err("Error parsing SPEC ID Event\n");
-             return ret;
-     }
-
-     ret = tcg2_pcr_read(dev, 0, &digest_list);
-     if (ret) {
-             log_err("Error reading PCR 0\n");
-             return ret;
-     }
-
-     /*
-      * If PCR0 is 0, previous firmware didn't have the capability
-      * to extend the PCR. In this scenario, extend the PCR as
-      * the eventlog is parsed.
-      */
-     for (i = 0; i < digest_list.count; i++) {
-             u8 hash_buf[TPM2_SHA512_DIGEST_SIZE] = { 0 };
-             u16 hash_alg = digest_list.digests[i].hash_alg;
-
-             if (!memcmp((u8 *)&digest_list.digests[i].digest, hash_buf,
-                         alg_to_len(hash_alg)))
-                     extend_pcr = true;
-     }
-
-     while (pos < sz) {
-             ret = tcg2_parse_event(dev, buffer, sz, &pos, &digest_list,
-                                    &pcr);
-             if (ret) {
-                     log_err("Error parsing event\n");
-                     return ret;
-             }
-             if (extend_pcr) {
-                     ret = tcg2_pcr_extend(dev, pcr, &digest_list);
-                     if (ret != EFI_SUCCESS) {
-                             log_err("Error in extending PCR\n");
-                             return ret;
-                     }
-
-                     /* Clear the digest for next event */
-                     for (i = 0; i < digest_list.count; i++) {
-                             u16 hash_alg = digest_list.digests[i].hash_alg;
-                             u8 *digest =
-                                (u8 *)&digest_list.digests[i].digest;
-
-                             memset(digest, 0, alg_to_len(hash_alg));
-                     }
-             }
-     }
-
-     memcpy(log_buffer, buffer, sz);
-     *log_sz = sz;
-
-     return ret;
-}
-
-/**
- * create_specid_event() - Create the first event in the eventlog
- *
- * @dev:                     tpm device
- * @event_header:            Pointer to the final event header
- * @event_size:                      final spec event size
- *
- * Return:   status code
- */
-static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
-                                     size_t *event_size)
-{
-     struct tcg_efi_spec_id_event *spec_event;
-     size_t spec_event_size;
-     efi_status_t ret = EFI_DEVICE_ERROR;
-     u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-     int err;
-     size_t i;
-
-     /*
-      * Create Spec event. This needs to be the first event in the log
-      * according to the TCG EFI protocol spec
-      */
-
-     /* Setup specID event data */
-     spec_event = (struct tcg_efi_spec_id_event *)buffer;
-     memcpy(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-            sizeof(spec_event->signature));
-     put_unaligned_le32(0, &spec_event->platform_class); /* type client */
-     spec_event->spec_version_minor =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2;
-     spec_event->spec_version_major =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2;
-     spec_event->spec_errata =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_ERRATA_TPM2;
-     spec_event->uintn_size = sizeof(efi_uintn_t) / sizeof(u32);
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-
-     if (err)
-             goto out;
-
-     for (i = 0; i < pcr_count; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
-             u16 hash_len = hash_algo_list[i].hash_len;
-
-             if (active & alg_to_mask(hash_alg)) {
-                     put_unaligned_le16(hash_alg,
-                                        &spec_event->digest_sizes[alg_count].algorithm_id);
-                     put_unaligned_le16(hash_len,
-                                        &spec_event->digest_sizes[alg_count].digest_size);
-                     alg_count++;
-             }
-     }
-
-     spec_event->number_of_algorithms = alg_count;
-     if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-         spec_event->number_of_algorithms < 1)
-             goto out;
-
-     /*
-      * the size of the spec event and placement of vendor_info_size
-      * depends on supported algoriths
-      */
-     spec_event_size =
-             offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-             spec_event->number_of_algorithms * sizeof(spec_event->digest_sizes[0]);
-     /* no vendor info for us */
-     memset(buffer + spec_event_size, 0, 1);
-     /* add a byte for vendor_info_size in the spec event */
-     spec_event_size += 1;
-     *event_size = spec_event_size;
-
-     return EFI_SUCCESS;
-
-out:
-     return ret;
-}
-
 /**
  * tcg2_uninit - remove the final event table and free efi memory on failures
  */
@@ -1722,7 +840,7 @@ out:
 }
 
 /**
- * tcg2_measure_event() - common function to add event log and extend PCR
+ * measure_event() - common function to add event log and extend PCR
  *
  * @dev:             TPM device
  * @pcr_index:               PCR index
@@ -1732,14 +850,13 @@ out:
  *
  * Return:   status code
  */
-static efi_status_t
-tcg2_measure_event(struct udevice *dev, u32 pcr_index, u32 event_type,
-                u32 size, u8 event[])
+static efi_status_t measure_event(struct udevice *dev, u32 pcr_index,
+                               u32 event_type, u32 size, u8 event[])
 {
      struct tpml_digest_values digest_list;
      efi_status_t ret;
 
-     ret = tcg2_create_digest(event, size, &digest_list);
+     ret = tcg2_create_digest(dev, event, size, &digest_list);
      if (ret != EFI_SUCCESS)
              goto out;
 
@@ -1766,9 +883,8 @@ static efi_status_t efi_append_scrtm_version(struct udevice *dev)
 {
      efi_status_t ret;
 
-     ret = tcg2_measure_event(dev, 0, EV_S_CRTM_VERSION,
-                              strlen(version_string) + 1,
-                              (u8 *)version_string);
+     ret = measure_event(dev, 0, EV_S_CRTM_VERSION,
+                         strlen(version_string) + 1, (u8 *)version_string);
 
      return ret;
 }
@@ -1784,12 +900,11 @@ static efi_status_t efi_init_event_log(void)
       * vendor_info_size is currently set to 0, we need to change the length
       * and allocate the flexible array member if this changes
       */
-     struct tcg_pcr_event *event_header = NULL;
+     struct tcg2_event_log elog;
      struct udevice *dev;
-     size_t spec_event_size;
      efi_status_t ret;
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              return ret;
 
@@ -1808,7 +923,6 @@ static efi_status_t efi_init_event_log(void)
       * The log header is defined to be in SHA1 event log entry format.
       * Setup event header
       */
-     event_header =  (struct tcg_pcr_event *)event_log.buffer;
      event_log.pos = 0;
      event_log.last_event_size = 0;
      event_log.get_event_called = false;

lib/efi_loader/efi_tcg2.c static efi_status_t efi_init_event_log(void) · line 938

Quoted 7 lines
lib/efi_loader/efi_tcg2.c +3 -1
@@ -1819,34 +933,19 @@ static efi_status_t efi_init_event_log(void)
       * Check if earlier firmware have passed any eventlog. Different
       * platforms can use different ways to do so.
       */
-     ret = tcg2_get_fw_eventlog(dev, event_log.buffer, &event_log.pos);
+     ret = tcg2_init_log(dev, &elog);
+     if (ret != EFI_SUCCESS)
+             goto free_pool;

So I think this is the last bit we need to change in order to support EFI properly. I read the email regarding the newly added reserved memory memory to the TPM node and it's fine, but that won't work for the existing U-Boot dtbs. Since this was working out of the box, I'd still prefer to keep that working even if that entry is missing.

If you look at this function, there is an efi_allocate_pool() call a few lines above. What this does is allocate the EventLog memory for EFI. Note here that this *has* to be EFI memory since the kernel's efi-stub can still call into the firmware (and in fact it does, that's who we measure the initrd in > 5.18 kernels). After the allocation it looks for those DT entries, and if tpm_event_log_addr is found it parses the EventLog and
1. Extends the PCRs
2. Adds the events into the Eventlog

Quoted 6 lines

The reason for that is that TF-A (the Arm first stage boot loader), doesn't have any TPM drivers. So U-Boot is trying to be 'smart' here. We are grabbing the EventLog from the previous bootloader and if PCR0!=0 we replay that into the hardware and re-create the EventLog.

[...]

This will fix the protocol installation, however there's still still something missing on the EFI side, since reading the eventlog fails with

tpm2_eventlog /sys/kernel/security/tpm0/binary_bios_measurements
version: 1
events:
ERROR: failed to parse tpm2 eventlog
ERROR: Unable to run tpm2_eventlog
But at least the kernel can find the EFI config tables properly. Also, note that the ret is efi_status_t and the new function you added returns an int. Just switch the ret here accordingly.

         * platforms can use different ways to do so.
         */
        ret = tcg2_init_log(dev, &elog);
-       if (ret != EFI_SUCCESS)
-               goto free_pool;
-
-       memcpy(event_log.buffer, elog.log, elog.log_position);
-       event_log.pos = elog.log_position;
+       if (ret == EFI_SUCCESS) {

+ memcpy(event_log.buffer, elog.log, elog.log_position);
+ event_log.pos = elog.log_position;
+ }

I'll try digging into the EFI issues more once I get some time

Cheers
/Ilias

Quoted 4 lines

Thanks!
/Ilias

Quoted 1 line
#6 lore raw
Quoted 952 lines · Ilias Apalodimas
Quoted 913 lines · Ilias Apalodimas

Hi Eddie,

        final_event->number_of_events++;
Quoted 886 lines
lib/efi_loader/efi_tcg2.c +30 -708
@@ -350,66 +142,6 @@ static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
      return ret;
 }
 
-/**
- * platform_get_tpm_device() - retrieve TPM device
- *
- * This function retrieves the udevice implementing a TPM
- *
- * This function may be overridden if special initialization is needed.
- *
- * @dev:     udevice
- * Return:   status code
- */
-__weak efi_status_t platform_get_tpm2_device(struct udevice **dev)
-{
-     for_each_tpm_device(*dev) {
-             /* Only support TPMv2 devices */
-             if (tpm_get_version(*dev) == TPM_V2)
-                     return EFI_SUCCESS;
-     }
-
-     return EFI_NOT_FOUND;
-}
-
-/**
- * platform_get_eventlog() - retrieve the eventlog address and size
- *
- * This function retrieves the eventlog address and size if the underlying
- * firmware has done some measurements and passed them.
- *
- * This function may be overridden based on platform specific method of
- * passing the eventlog address and size.
- *
- * @dev:     udevice
- * @addr:    eventlog address
- * @sz:              eventlog size
- * Return:   status code
- */
-__weak efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr,
-                                       u32 *sz)
-{
-     const u64 *basep;
-     const u32 *sizep;
-
-     basep = dev_read_prop(dev, "tpm_event_log_addr", NULL);
-     if (!basep)
-             return EFI_NOT_FOUND;
-
-     *addr = be64_to_cpup((__force __be64 *)basep);
-
-     sizep = dev_read_prop(dev, "tpm_event_log_size", NULL);
-     if (!sizep)
-             return EFI_NOT_FOUND;
-
-     *sz = be32_to_cpup((__force __be32 *)sizep);
-     if (*sz == 0) {
-             log_debug("event log empty\n");
-             return EFI_NOT_FOUND;
-     }
-
-     return EFI_SUCCESS;
-}
-
 /**
  * tpm2_get_max_command_size() - get the supported max command size
  *
@@ -485,239 +217,6 @@ static int tpm2_get_manufacturer_id(struct udevice *dev, u32 *manufacturer_id)
      return 0;
 }
 
-/**
- * tpm2_get_num_pcr() - get the number of PCRs
- *
- * @dev:             TPM device
- * @manufacturer_id: output buffer for the number
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_num_pcr(struct udevice *dev, u32 *num_pcr)
-{
-     u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-     u32 ret;
-
-     memset(response, 0, sizeof(response));
-     ret = tpm2_get_capability(dev, TPM2_CAP_TPM_PROPERTIES,
-                               TPM2_PT_PCR_COUNT, response, 1);
-     if (ret)
-             return -1;
-
-     *num_pcr = get_unaligned_be32(response + properties_offset);
-     if (*num_pcr > TPM2_MAX_PCRS)
-             return -1;
-
-     return 0;
-}
-
-/**
- * is_active_pcr() - Check if a supported algorithm is active
- *
- * @dev:             TPM device
- * @selection:               struct of PCR information
- *
- * Return: true if PCR is active
- */
-static bool is_active_pcr(struct tpms_pcr_selection *selection)
-{
-     int i;
-     /*
-      * check the pcr_select. If at least one of the PCRs supports the
-      * algorithm add it on the active ones
-      */
-     for (i = 0; i < selection->size_of_select; i++) {
-             if (selection->pcr_select[i])
-                     return true;
-     }
-
-     return false;
-}
-
-/**
- * tpm2_get_pcr_info() - get the supported, active PCRs and number of banks
- *
- * @dev:             TPM device
- * @supported_pcr:   bitmask with the algorithms supported
- * @active_pcr:              bitmask with the active algorithms
- * @pcr_banks:               number of PCR banks
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_pcr_info(struct udevice *dev, u32 *supported_pcr,
-                          u32 *active_pcr, u32 *pcr_banks)
-{
-     u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-     struct tpml_pcr_selection pcrs;
-     u32 ret, num_pcr;
-     size_t i;
-     int tpm_ret;
-
-     *supported_pcr = 0;
-     *active_pcr = 0;
-     *pcr_banks = 0;
-     memset(response, 0, sizeof(response));
-     ret = tpm2_get_capability(dev, TPM2_CAP_PCRS, 0, response, 1);
-     if (ret)
-             goto out;
-
-     pcrs.count = get_unaligned_be32(response);
-     /*
-      * We only support 5 algorithms for now so check against that
-      * instead of TPM2_NUM_PCR_BANKS
-      */
-     if (pcrs.count > MAX_HASH_COUNT || pcrs.count < 1)
-             goto out;
-
-     tpm_ret = tpm2_get_num_pcr(dev, &num_pcr);
-     if (tpm_ret)
-             goto out;
-
-     for (i = 0; i < pcrs.count; i++) {
-             /*
-              * Definition of TPMS_PCR_SELECTION Structure
-              * hash: u16
-              * size_of_select: u8
-              * pcr_select: u8 array
-              *
-              * The offsets depend on the number of the device PCRs
-              * so we have to calculate them based on that
-              */
-             u32 hash_offset = offsetof(struct tpml_pcr_selection, selection) +
-                     i * offsetof(struct tpms_pcr_selection, pcr_select) +
-                     i * ((num_pcr + 7) / 8);
-             u32 size_select_offset =
-                     hash_offset + offsetof(struct tpms_pcr_selection,
-                                            size_of_select);
-             u32 pcr_select_offset =
-                     hash_offset + offsetof(struct tpms_pcr_selection,
-                                            pcr_select);
-
-             pcrs.selection[i].hash =
-                     get_unaligned_be16(response + hash_offset);
-             pcrs.selection[i].size_of_select =
-                     __get_unaligned_be(response + size_select_offset);
-             if (pcrs.selection[i].size_of_select > TPM2_PCR_SELECT_MAX)
-                     goto out;
-             /* copy the array of pcr_select */
-             memcpy(pcrs.selection[i].pcr_select, response + pcr_select_offset,
-                    pcrs.selection[i].size_of_select);
-     }
-
-     for (i = 0; i < pcrs.count; i++) {
-             u32 hash_mask = alg_to_mask(pcrs.selection[i].hash);
-
-             if (hash_mask) {
-                     *supported_pcr |= hash_mask;
-                     if (is_active_pcr(&pcrs.selection[i]))
-                             *active_pcr |= hash_mask;
-             } else {
-                     EFI_PRINT("Unknown algorithm %x\n", pcrs.selection[i].hash);
-             }
-     }
-
-     *pcr_banks = pcrs.count;
-
-     return 0;
-out:
-     return -1;
-}
-
-/**
- * __get_active_pcr_banks() - returns the currently active PCR banks
- *
- * @active_pcr_banks:                pointer for receiving the bitmap of currently
- *                           active PCR banks
- *
- * Return:   status code
- */
-static efi_status_t __get_active_pcr_banks(u32 *active_pcr_banks)
-{
-     struct udevice *dev;
-     u32 active = 0, supported = 0, pcr_banks = 0;
-     efi_status_t ret;
-     int err;
-
-     ret = platform_get_tpm2_device(&dev);
-     if (ret != EFI_SUCCESS)
-             goto out;
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_banks);
-     if (err) {
-             ret = EFI_DEVICE_ERROR;
-             goto out;
-     }
-
-     *active_pcr_banks = active;
-
-out:
-     return ret;
-}
-
-/* tcg2_create_digest - create a list of digests of the supported PCR banks
- *                   for a given memory range
- *
- * @input:           input memory
- * @length:          length of buffer to calculate the digest
- * @digest_list:     list of digests to fill in
- *
- * Return:           status code
- */
-static efi_status_t tcg2_create_digest(const u8 *input, u32 length,
-                                    struct tpml_digest_values *digest_list)
-{
-     sha1_context ctx;
-     sha256_context ctx_256;
-     sha512_context ctx_512;
-     u8 final[TPM2_SHA512_DIGEST_SIZE];
-     efi_status_t ret;
-     u32 active;
-     size_t i;
-
-     ret = __get_active_pcr_banks(&active);
-     if (ret != EFI_SUCCESS)
-             return ret;
-
-     digest_list->count = 0;
-     for (i = 0; i < MAX_HASH_COUNT; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
-
-             if (!(active & alg_to_mask(hash_alg)))
-                     continue;
-             switch (hash_alg) {
-             case TPM2_ALG_SHA1:
-                     sha1_starts(&ctx);
-                     sha1_update(&ctx, input, length);
-                     sha1_finish(&ctx, final);
-                     break;
-             case TPM2_ALG_SHA256:
-                     sha256_starts(&ctx_256);
-                     sha256_update(&ctx_256, input, length);
-                     sha256_finish(&ctx_256, final);
-                     break;
-             case TPM2_ALG_SHA384:
-                     sha384_starts(&ctx_512);
-                     sha384_update(&ctx_512, input, length);
-                     sha384_finish(&ctx_512, final);
-                     break;
-             case TPM2_ALG_SHA512:
-                     sha512_starts(&ctx_512);
-                     sha512_update(&ctx_512, input, length);
-                     sha512_finish(&ctx_512, final);
-                     break;
-             default:
-                     EFI_PRINT("Unsupported algorithm %x\n", hash_alg);
-                     return EFI_INVALID_PARAMETER;
-             }
-             digest_list->digests[digest_list->count].hash_alg = hash_alg;
-             memcpy(&digest_list->digests[digest_list->count].digest, final,
-                    (u32)alg_to_len(hash_alg));
-             digest_list->count++;
-     }
-
-     return EFI_SUCCESS;
-}
-
 /**
  * efi_tcg2_get_capability() - protocol capability information and state information
  *
@@ -759,7 +258,7 @@ efi_tcg2_get_capability(struct efi_tcg2_protocol *this,
      capability->protocol_version.major = 1;
      capability->protocol_version.minor = 1;
 
-     efi_ret = platform_get_tpm2_device(&dev);
+     efi_ret = tcg2_platform_get_tpm2(&dev);
      if (efi_ret != EFI_SUCCESS) {
              capability->supported_event_logs = 0;
              capability->hash_algorithm_bitmap = 0;
@@ -855,7 +354,7 @@ efi_tcg2_get_eventlog(struct efi_tcg2_protocol *this,
              goto out;
      }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS) {
              event_log_location = NULL;
              event_log_last_entry = NULL;
@@ -890,6 +389,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
      struct efi_image_regions *regs = NULL;
      void *new_efi = NULL;
      u8 hash[TPM2_SHA512_DIGEST_SIZE];
+     struct udevice *dev;
      efi_status_t ret;
      u32 active;
      int i;
@@ -905,16 +405,20 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
              goto out;
      }
 
-     ret = __get_active_pcr_banks(&active);
+     ret = tcg2_platform_get_tpm2(&dev);
+     if (ret != EFI_SUCCESS)
+             goto out;
+
+     ret = tcg2_get_active_pcr_banks(dev, &active);
      if (ret != EFI_SUCCESS) {
              goto out;
      }
 
      digest_list->count = 0;
-     for (i = 0; i < MAX_HASH_COUNT; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
+     for (i = 0; i < ARRAY_SIZE(tpm2_supported_algorithms); i++) {
+             u16 hash_alg = tpm2_supported_algorithms[i];
 
-             if (!(active & alg_to_mask(hash_alg)))
+             if (!(active & tpm2_algorithm_to_mask(hash_alg)))
                      continue;
              switch (hash_alg) {
              case TPM2_ALG_SHA1:
@@ -935,7 +439,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
              }
              digest_list->digests[digest_list->count].hash_alg = hash_alg;
              memcpy(&digest_list->digests[digest_list->count].digest, hash,
-                    (u32)alg_to_len(hash_alg));
+                    (u32)tpm2_algorithm_to_len(hash_alg));
              digest_list->count++;
      }
 
@@ -975,7 +479,7 @@ efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size,
      if (!is_tcg2_protocol_installed())
              return EFI_SUCCESS;
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              return EFI_SECURITY_VIOLATION;
 
@@ -1084,7 +588,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
              goto out;
      }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              goto out;
 
@@ -1119,7 +623,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
              ret = tcg2_hash_pe_image((void *)(uintptr_t)data_to_hash,
                                       data_to_hash_len, &digest_list);
      } else {
-             ret = tcg2_create_digest((u8 *)(uintptr_t)data_to_hash,
+             ret = tcg2_create_digest(dev, (u8 *)(uintptr_t)data_to_hash,
                                       data_to_hash_len, &digest_list);
      }
 
@@ -1182,7 +686,7 @@ efi_tcg2_submit_command(struct efi_tcg2_protocol *this,
              goto out;
      }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              goto out;
 
@@ -1211,6 +715,7 @@ static efi_status_t EFIAPI
 efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
                            u32 *active_pcr_banks)
 {
+     struct udevice *dev;
      efi_status_t ret;
 
      if (!this || !active_pcr_banks) {
@@ -1218,8 +723,12 @@ efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
              goto out;
      }
 
+     ret = tcg2_platform_get_tpm2(&dev);
+     if (ret != EFI_SUCCESS)
+             goto out;
+
      EFI_ENTRY("%p, %p", this, active_pcr_banks);
-     ret = __get_active_pcr_banks(active_pcr_banks);
+     ret = tcg2_get_active_pcr_banks(dev, active_pcr_banks);
 
 out:
      return EFI_EXIT(ret);
@@ -1270,397 +779,6 @@ static const struct efi_tcg2_protocol efi_tcg2_protocol = {
      .get_result_of_set_active_pcr_banks = efi_tcg2_get_result_of_set_active_pcr_banks,
 };
 
-/**
- * parse_event_log_header() -  Parse and verify the event log header fields
- *
- * @buffer:                  Pointer to the start of the eventlog
- * @size:                    Size of the eventlog
- * @pos:                     Return offset of the next event in buffer right
- *                           after the event header i.e specID
- *
- * Return:   status code
- */
-static efi_status_t parse_event_log_header(void *buffer, u32 size, u32 *pos)
-{
-     struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-     int i = 0;
-
-     if (size < sizeof(*event_header))
-             return EFI_COMPROMISED_DATA;
-
-     if (get_unaligned_le32(&event_header->pcr_index) != 0 ||
-         get_unaligned_le32(&event_header->event_type) != EV_NO_ACTION)
-             return EFI_COMPROMISED_DATA;
-
-     for (i = 0; i < sizeof(event_header->digest); i++) {
-             if (event_header->digest[i])
-                     return EFI_COMPROMISED_DATA;
-     }
-
-     *pos += sizeof(*event_header);
-
-     return EFI_SUCCESS;
-}
-
-/**
- * parse_specid_event() -  Parse and verify the specID Event in the eventlog
- *
- * @dev:             udevice
- * @buffer:          Pointer to the start of the eventlog
- * @log_size:                Size of the eventlog
- * @pos:             [in] Offset of specID event in the eventlog buffer
- *                   [out] Return offset of the next event in the buffer
- *                   after the specID
- * @digest_list:     list of digests in the event
- *
- * Return:           status code
- * @pos                      Offset in the eventlog where the specID event ends
- * @digest_list:     list of digests in the event
- */
-static efi_status_t parse_specid_event(struct udevice *dev, void *buffer,
-                                    u32 log_size, u32 *pos,
-                                    struct tpml_digest_values *digest_list)
-{
-     struct tcg_efi_spec_id_event *spec_event;
-     struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-     size_t spec_event_size;
-     u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-     u32 spec_active = 0;
-     u16 hash_alg;
-     u8 vendor_sz;
-     int err, i;
-
-     if (*pos >= log_size || (*pos + sizeof(*spec_event)) > log_size)
-             return EFI_COMPROMISED_DATA;
-
-     /* Check specID event data */
-     spec_event = (struct tcg_efi_spec_id_event *)((uintptr_t)buffer + *pos);
-     /* Check for signature */
-     if (memcmp(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-                sizeof(TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03))) {
-             log_err("specID Event: Signature mismatch\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     if (spec_event->spec_version_minor !=
-                     TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2 ||
-         spec_event->spec_version_major !=
-                     TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2)
-             return EFI_COMPROMISED_DATA;
-
-     if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-         spec_event->number_of_algorithms < 1) {
-             log_err("specID Event: Number of algorithms incorrect\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     alg_count = spec_event->number_of_algorithms;
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-     if (err)
-             return EFI_DEVICE_ERROR;
-
-     digest_list->count = 0;
-     /*
-      * We have to take care that the sequence of algorithms that we record
-      * in digest_list matches the sequence in eventlog.
-      */
-     for (i = 0; i < alg_count; i++) {
-             hash_alg =
-               get_unaligned_le16(&spec_event->digest_sizes[i].algorithm_id);
-
-             if (!(supported & alg_to_mask(hash_alg))) {
-                     log_err("specID Event: Unsupported algorithm\n");
-                     return EFI_COMPROMISED_DATA;
-             }
-             digest_list->digests[digest_list->count++].hash_alg = hash_alg;
-
-             spec_active |= alg_to_mask(hash_alg);
-     }
-
-     /*
-      * TCG specification expects the event log to have hashes for all
-      * active PCR's
-      */
-     if (spec_active != active) {
-             /*
-              * Previous stage bootloader should know all the active PCR's
-              * and use them in the Eventlog.
-              */
-             log_err("specID Event: All active hash alg not present\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     /*
-      * the size of the spec event and placement of vendor_info_size
-      * depends on supported algoriths
-      */
-     spec_event_size =
-             offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-             alg_count * sizeof(spec_event->digest_sizes[0]);
-
-     if (*pos + spec_event_size >= log_size)
-             return EFI_COMPROMISED_DATA;
-
-     vendor_sz = *(uint8_t *)((uintptr_t)buffer + *pos + spec_event_size);
-
-     spec_event_size += sizeof(vendor_sz) + vendor_sz;
-     *pos += spec_event_size;
-
-     if (get_unaligned_le32(&event_header->event_size) != spec_event_size) {
-             log_err("specID event: header event size mismatch\n");
-             /* Right way to handle this can be to call SetActive PCR's */
-             return EFI_COMPROMISED_DATA;
-     }
-
-     return EFI_SUCCESS;
-}
-
-/**
- * tcg2_parse_event() -  Parse the event in the eventlog
- *
- * @dev:             udevice
- * @buffer:          Pointer to the start of the eventlog
- * @log_size:                Size of the eventlog
- * @offset:          [in] Offset of the event in the eventlog buffer
- *                   [out] Return offset of the next event in the buffer
- * @digest_list:     list of digests in the event
- * @pcr                      Index of the PCR in the event
- *
- * Return:           status code
- */
-static efi_status_t tcg2_parse_event(struct udevice *dev, void *buffer,
-                                  u32 log_size, u32 *offset,
-                                  struct tpml_digest_values *digest_list,
-                                  u32 *pcr)
-{
-     struct tcg_pcr_event2 *event = NULL;
-     u32 count, size, event_size;
-     size_t pos;
-
-     event_size = tcg_event_final_size(digest_list);
-     if (*offset >= log_size || *offset + event_size > log_size) {
-             log_err("Event exceeds log size\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     event = (struct tcg_pcr_event2 *)((uintptr_t)buffer + *offset);
-     *pcr = get_unaligned_le32(&event->pcr_index);
-
-     /* get the count */
-     count = get_unaligned_le32(&event->digests.count);
-     if (count != digest_list->count)
-             return EFI_COMPROMISED_DATA;
-
-     pos = offsetof(struct tcg_pcr_event2, digests);
-     pos += offsetof(struct tpml_digest_values, digests);
-
-     for (int i = 0; i < digest_list->count; i++) {
-             u16 alg;
-             u16 hash_alg = digest_list->digests[i].hash_alg;
-             u8 *digest = (u8 *)&digest_list->digests[i].digest;
-
-             alg = get_unaligned_le16((void *)((uintptr_t)event + pos));
-
-             if (alg != hash_alg)
-                     return EFI_COMPROMISED_DATA;
-
-             pos += offsetof(struct tpmt_ha, digest);
-             memcpy(digest, (void *)((uintptr_t)event + pos), alg_to_len(hash_alg));
-             pos += alg_to_len(hash_alg);
-     }
-
-     size = get_unaligned_le32((void *)((uintptr_t)event + pos));
-     event_size += size;
-     pos += sizeof(u32); /* tcg_pcr_event2 event_size*/
-     pos += size;
-
-     /* make sure the calculated buffer is what we checked against */
-     if (pos != event_size)
-             return EFI_COMPROMISED_DATA;
-
-     if (pos > log_size)
-             return EFI_COMPROMISED_DATA;
-
-     *offset += pos;
-
-     return EFI_SUCCESS;
-}
-
-/**
- * tcg2_get_fw_eventlog() -  Get the eventlog address and size
- *
- * If the previous firmware has passed some eventlog, this function get it's
- * location and check for it's validity.
- *
- * @dev:             udevice
- * @log_buffer:              eventlog address
- * @log_sz:          eventlog size
- *
- * Return:   status code
- */
-static efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer,
-                                      size_t *log_sz)
-{
-     struct tpml_digest_values digest_list;
-     void *buffer;
-     efi_status_t ret;
-     u32 pcr, pos;
-     u64 base;
-     u32 sz;
-     bool extend_pcr = false;
-     int i;
-
-     ret = platform_get_eventlog(dev, &base, &sz);
-     if (ret != EFI_SUCCESS)
-             return ret;
-
-     if (sz > TPM2_EVENT_LOG_SIZE)
-             return EFI_VOLUME_FULL;
-
-     buffer = (void *)(uintptr_t)base;
-     pos = 0;
-     /* Parse the eventlog to check for its validity */
-     ret = parse_event_log_header(buffer, sz, &pos);
-     if (ret)
-             return ret;
-
-     ret = parse_specid_event(dev, buffer, sz, &pos, &digest_list);
-     if (ret) {
-             log_err("Error parsing SPEC ID Event\n");
-             return ret;
-     }
-
-     ret = tcg2_pcr_read(dev, 0, &digest_list);
-     if (ret) {
-             log_err("Error reading PCR 0\n");
-             return ret;
-     }
-
-     /*
-      * If PCR0 is 0, previous firmware didn't have the capability
-      * to extend the PCR. In this scenario, extend the PCR as
-      * the eventlog is parsed.
-      */
-     for (i = 0; i < digest_list.count; i++) {
-             u8 hash_buf[TPM2_SHA512_DIGEST_SIZE] = { 0 };
-             u16 hash_alg = digest_list.digests[i].hash_alg;
-
-             if (!memcmp((u8 *)&digest_list.digests[i].digest, hash_buf,
-                         alg_to_len(hash_alg)))
-                     extend_pcr = true;
-     }
-
-     while (pos < sz) {
-             ret = tcg2_parse_event(dev, buffer, sz, &pos, &digest_list,
-                                    &pcr);
-             if (ret) {
-                     log_err("Error parsing event\n");
-                     return ret;
-             }
-             if (extend_pcr) {
-                     ret = tcg2_pcr_extend(dev, pcr, &digest_list);
-                     if (ret != EFI_SUCCESS) {
-                             log_err("Error in extending PCR\n");
-                             return ret;
-                     }
-
-                     /* Clear the digest for next event */
-                     for (i = 0; i < digest_list.count; i++) {
-                             u16 hash_alg = digest_list.digests[i].hash_alg;
-                             u8 *digest =
-                                (u8 *)&digest_list.digests[i].digest;
-
-                             memset(digest, 0, alg_to_len(hash_alg));
-                     }
-             }
-     }
-
-     memcpy(log_buffer, buffer, sz);
-     *log_sz = sz;
-
-     return ret;
-}
-
-/**
- * create_specid_event() - Create the first event in the eventlog
- *
- * @dev:                     tpm device
- * @event_header:            Pointer to the final event header
- * @event_size:                      final spec event size
- *
- * Return:   status code
- */
-static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
-                                     size_t *event_size)
-{
-     struct tcg_efi_spec_id_event *spec_event;
-     size_t spec_event_size;
-     efi_status_t ret = EFI_DEVICE_ERROR;
-     u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-     int err;
-     size_t i;
-
-     /*
-      * Create Spec event. This needs to be the first event in the log
-      * according to the TCG EFI protocol spec
-      */
-
-     /* Setup specID event data */
-     spec_event = (struct tcg_efi_spec_id_event *)buffer;
-     memcpy(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-            sizeof(spec_event->signature));
-     put_unaligned_le32(0, &spec_event->platform_class); /* type client */
-     spec_event->spec_version_minor =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2;
-     spec_event->spec_version_major =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2;
-     spec_event->spec_errata =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_ERRATA_TPM2;
-     spec_event->uintn_size = sizeof(efi_uintn_t) / sizeof(u32);
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-
-     if (err)
-             goto out;
-
-     for (i = 0; i < pcr_count; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
-             u16 hash_len = hash_algo_list[i].hash_len;
-
-             if (active & alg_to_mask(hash_alg)) {
-                     put_unaligned_le16(hash_alg,
-                                        &spec_event->digest_sizes[alg_count].algorithm_id);
-                     put_unaligned_le16(hash_len,
-                                        &spec_event->digest_sizes[alg_count].digest_size);
-                     alg_count++;
-             }
-     }
-
-     spec_event->number_of_algorithms = alg_count;
-     if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-         spec_event->number_of_algorithms < 1)
-             goto out;
-
-     /*
-      * the size of the spec event and placement of vendor_info_size
-      * depends on supported algoriths
-      */
-     spec_event_size =
-             offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-             spec_event->number_of_algorithms * sizeof(spec_event->digest_sizes[0]);
-     /* no vendor info for us */
-     memset(buffer + spec_event_size, 0, 1);
-     /* add a byte for vendor_info_size in the spec event */
-     spec_event_size += 1;
-     *event_size = spec_event_size;
-
-     return EFI_SUCCESS;
-
-out:
-     return ret;
-}
-
 /**
  * tcg2_uninit - remove the final event table and free efi memory on failures
  */
@@ -1722,7 +840,7 @@ out:
 }
 
 /**
- * tcg2_measure_event() - common function to add event log and extend PCR
+ * measure_event() - common function to add event log and extend PCR
  *
  * @dev:             TPM device
  * @pcr_index:               PCR index
@@ -1732,14 +850,13 @@ out:
  *
  * Return:   status code
  */
-static efi_status_t
-tcg2_measure_event(struct udevice *dev, u32 pcr_index, u32 event_type,
-                u32 size, u8 event[])
+static efi_status_t measure_event(struct udevice *dev, u32 pcr_index,
+                               u32 event_type, u32 size, u8 event[])
 {
      struct tpml_digest_values digest_list;
      efi_status_t ret;
 
-     ret = tcg2_create_digest(event, size, &digest_list);
+     ret = tcg2_create_digest(dev, event, size, &digest_list);
      if (ret != EFI_SUCCESS)
              goto out;
 
@@ -1766,9 +883,8 @@ static efi_status_t efi_append_scrtm_version(struct udevice *dev)
 {
      efi_status_t ret;
 
-     ret = tcg2_measure_event(dev, 0, EV_S_CRTM_VERSION,
-                              strlen(version_string) + 1,
-                              (u8 *)version_string);
+     ret = measure_event(dev, 0, EV_S_CRTM_VERSION,
+                         strlen(version_string) + 1, (u8 *)version_string);
 
      return ret;
 }
@@ -1784,12 +900,11 @@ static efi_status_t efi_init_event_log(void)
       * vendor_info_size is currently set to 0, we need to change the length
       * and allocate the flexible array member if this changes
       */
-     struct tcg_pcr_event *event_header = NULL;
+     struct tcg2_event_log elog;
      struct udevice *dev;
-     size_t spec_event_size;
      efi_status_t ret;
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
      if (ret != EFI_SUCCESS)
              return ret;
 
@@ -1808,7 +923,6 @@ static efi_status_t efi_init_event_log(void)
       * The log header is defined to be in SHA1 event log entry format.
       * Setup event header
       */
-     event_header =  (struct tcg_pcr_event *)event_log.buffer;
      event_log.pos = 0;
      event_log.last_event_size = 0;
      event_log.get_event_called = false;

lib/efi_loader/efi_tcg2.c static efi_status_t efi_init_event_log(void) · line 938

Quoted 7 lines
lib/efi_loader/efi_tcg2.c +3 -1
@@ -1819,34 +933,19 @@ static efi_status_t efi_init_event_log(void)
       * Check if earlier firmware have passed any eventlog. Different
       * platforms can use different ways to do so.
       */
-     ret = tcg2_get_fw_eventlog(dev, event_log.buffer, &event_log.pos);
+     ret = tcg2_init_log(dev, &elog);
+     if (ret != EFI_SUCCESS)
+             goto free_pool;

So I think this is the last bit we need to change in order to support EFI properly. I read the email regarding the newly added reserved memory memory to the TPM node and it's fine, but that won't work for the existing U-Boot dtbs. Since this was working out of the box, I'd still prefer to keep that working even if that entry is missing.

If you look at this function, there is an efi_allocate_pool() call a few lines above. What this does is allocate the EventLog memory for EFI. Note here that this *has* to be EFI memory since the kernel's efi-stub can still call into the firmware (and in fact it does, that's who we measure the initrd in > 5.18 kernels). After the allocation it looks for those DT entries, and if tpm_event_log_addr is found it parses the EventLog and
1. Extends the PCRs
2. Adds the events into the Eventlog

Quoted 6 lines

The reason for that is that TF-A (the Arm first stage boot loader), doesn't have any TPM drivers. So U-Boot is trying to be 'smart' here. We are grabbing the EventLog from the previous bootloader and if PCR0!=0 we replay that into the hardware and re-create the EventLog.

[...]

This will fix the protocol installation, however there's still still something missing on the EFI side, since reading the eventlog fails with

tpm2_eventlog /sys/kernel/security/tpm0/binary_bios_measurements
version: 1
events:
ERROR: failed to parse tpm2 eventlog
ERROR: Unable to run tpm2_eventlog
But at least the kernel can find the EFI config tables properly. Also, note that the ret is efi_status_t and the new function you added returns an int. Just switch the ret here accordingly.

         * platforms can use different ways to do so.
         */
        ret = tcg2_init_log(dev, &elog);
(quoted diff) +4 -5
-       if (ret != EFI_SUCCESS)
-               goto free_pool;
-
-       memcpy(event_log.buffer, elog.log, elog.log_position);
-       event_log.pos = elog.log_position;
+       if (ret == EFI_SUCCESS) {
+               memcpy(event_log.buffer, elog.log, elog.log_position);
+               event_log.pos = elog.log_position;
+       }
Quoted 1 line

I'll try digging into the EFI issues more once I get some time

Ok Ignore the previous mail. I just noticed that the specid event is generated by tcg2_log_init() and that's where the errors come from.

So something like the *really ugly hack* fixes EFI. Can you please turn it into human-readable code

#include <linux/unaligned/be_byteshift.h>
#include <linux/unaligned/generic.h>
#include <linux/unaligned/le_byteshift.h>
+#include <malloc.h>

#include "tpm-utils.h"

@@ -634,7 +635,7 @@ __weak int tcg2_platform_get_log(struct udevice *dev, void **addr, u32 *size)

if (dev_read_phandle_with_args(dev, "memory-region", NULL, 0,
0, &args))
- return -ENODEV;
+ goto alloc;

                a = ofnode_get_addr_size(args.node, "reg", &s);
                if (a == FDT_ADDR_T_NONE)
@@ -643,6 +644,9 @@ __weak int tcg2_platform_get_log(struct udevice
*dev, void **addr, u32 *size)
                *addr = map_physmem(a, s, MAP_NOCACHE);
                *size = (u32)s;
        }

+alloc:
+ *addr = calloc(1, 4096);
+ *size = 4096;

        return 0;

}

Cheers
/Ilias

Quoted 7 lines

Cheers
/Ilias

Quoted 4 lines

Thanks!
/Ilias

Quoted 1 line
#7 lore raw
Quoted 950 lines · Ilias Apalodimas
Quoted 948 lines · Ilias Apalodimas
Quoted 911 lines · Ilias Apalodimas

Hi Eddie,

         final_event->number_of_events++;
Quoted 886 lines
lib/efi_loader/efi_tcg2.c +30 -708
@@ -350,66 +142,6 @@ static efi_status_t tcg2_agile_log_append(u32 pcr_index, u32 event_type,
       return ret;
  }
 
-/**
- * platform_get_tpm_device() - retrieve TPM device
- *
- * This function retrieves the udevice implementing a TPM
- *
- * This function may be overridden if special initialization is needed.
- *
- * @dev:     udevice
- * Return:   status code
- */
-__weak efi_status_t platform_get_tpm2_device(struct udevice **dev)
-{
-     for_each_tpm_device(*dev) {
-             /* Only support TPMv2 devices */
-             if (tpm_get_version(*dev) == TPM_V2)
-                     return EFI_SUCCESS;
-     }
-
-     return EFI_NOT_FOUND;
-}
-
-/**
- * platform_get_eventlog() - retrieve the eventlog address and size
- *
- * This function retrieves the eventlog address and size if the underlying
- * firmware has done some measurements and passed them.
- *
- * This function may be overridden based on platform specific method of
- * passing the eventlog address and size.
- *
- * @dev:     udevice
- * @addr:    eventlog address
- * @sz:              eventlog size
- * Return:   status code
- */
-__weak efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr,
-                                       u32 *sz)
-{
-     const u64 *basep;
-     const u32 *sizep;
-
-     basep = dev_read_prop(dev, "tpm_event_log_addr", NULL);
-     if (!basep)
-             return EFI_NOT_FOUND;
-
-     *addr = be64_to_cpup((__force __be64 *)basep);
-
-     sizep = dev_read_prop(dev, "tpm_event_log_size", NULL);
-     if (!sizep)
-             return EFI_NOT_FOUND;
-
-     *sz = be32_to_cpup((__force __be32 *)sizep);
-     if (*sz == 0) {
-             log_debug("event log empty\n");
-             return EFI_NOT_FOUND;
-     }
-
-     return EFI_SUCCESS;
-}
-
  /**
   * tpm2_get_max_command_size() - get the supported max command size
   *
@@ -485,239 +217,6 @@ static int tpm2_get_manufacturer_id(struct udevice *dev, u32 *manufacturer_id)
       return 0;
  }
 
-/**
- * tpm2_get_num_pcr() - get the number of PCRs
- *
- * @dev:             TPM device
- * @manufacturer_id: output buffer for the number
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_num_pcr(struct udevice *dev, u32 *num_pcr)
-{
-     u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-     u32 ret;
-
-     memset(response, 0, sizeof(response));
-     ret = tpm2_get_capability(dev, TPM2_CAP_TPM_PROPERTIES,
-                               TPM2_PT_PCR_COUNT, response, 1);
-     if (ret)
-             return -1;
-
-     *num_pcr = get_unaligned_be32(response + properties_offset);
-     if (*num_pcr > TPM2_MAX_PCRS)
-             return -1;
-
-     return 0;
-}
-
-/**
- * is_active_pcr() - Check if a supported algorithm is active
- *
- * @dev:             TPM device
- * @selection:               struct of PCR information
- *
- * Return: true if PCR is active
- */
-static bool is_active_pcr(struct tpms_pcr_selection *selection)
-{
-     int i;
-     /*
-      * check the pcr_select. If at least one of the PCRs supports the
-      * algorithm add it on the active ones
-      */
-     for (i = 0; i < selection->size_of_select; i++) {
-             if (selection->pcr_select[i])
-                     return true;
-     }
-
-     return false;
-}
-
-/**
- * tpm2_get_pcr_info() - get the supported, active PCRs and number of banks
- *
- * @dev:             TPM device
- * @supported_pcr:   bitmask with the algorithms supported
- * @active_pcr:              bitmask with the active algorithms
- * @pcr_banks:               number of PCR banks
- *
- * Return: 0 on success, -1 on error
- */
-static int tpm2_get_pcr_info(struct udevice *dev, u32 *supported_pcr,
-                          u32 *active_pcr, u32 *pcr_banks)
-{
-     u8 response[TPM2_RESPONSE_BUFFER_SIZE];
-     struct tpml_pcr_selection pcrs;
-     u32 ret, num_pcr;
-     size_t i;
-     int tpm_ret;
-
-     *supported_pcr = 0;
-     *active_pcr = 0;
-     *pcr_banks = 0;
-     memset(response, 0, sizeof(response));
-     ret = tpm2_get_capability(dev, TPM2_CAP_PCRS, 0, response, 1);
-     if (ret)
-             goto out;
-
-     pcrs.count = get_unaligned_be32(response);
-     /*
-      * We only support 5 algorithms for now so check against that
-      * instead of TPM2_NUM_PCR_BANKS
-      */
-     if (pcrs.count > MAX_HASH_COUNT || pcrs.count < 1)
-             goto out;
-
-     tpm_ret = tpm2_get_num_pcr(dev, &num_pcr);
-     if (tpm_ret)
-             goto out;
-
-     for (i = 0; i < pcrs.count; i++) {
-             /*
-              * Definition of TPMS_PCR_SELECTION Structure
-              * hash: u16
-              * size_of_select: u8
-              * pcr_select: u8 array
-              *
-              * The offsets depend on the number of the device PCRs
-              * so we have to calculate them based on that
-              */
-             u32 hash_offset = offsetof(struct tpml_pcr_selection, selection) +
-                     i * offsetof(struct tpms_pcr_selection, pcr_select) +
-                     i * ((num_pcr + 7) / 8);
-             u32 size_select_offset =
-                     hash_offset + offsetof(struct tpms_pcr_selection,
-                                            size_of_select);
-             u32 pcr_select_offset =
-                     hash_offset + offsetof(struct tpms_pcr_selection,
-                                            pcr_select);
-
-             pcrs.selection[i].hash =
-                     get_unaligned_be16(response + hash_offset);
-             pcrs.selection[i].size_of_select =
-                     __get_unaligned_be(response + size_select_offset);
-             if (pcrs.selection[i].size_of_select > TPM2_PCR_SELECT_MAX)
-                     goto out;
-             /* copy the array of pcr_select */
-             memcpy(pcrs.selection[i].pcr_select, response + pcr_select_offset,
-                    pcrs.selection[i].size_of_select);
-     }
-
-     for (i = 0; i < pcrs.count; i++) {
-             u32 hash_mask = alg_to_mask(pcrs.selection[i].hash);
-
-             if (hash_mask) {
-                     *supported_pcr |= hash_mask;
-                     if (is_active_pcr(&pcrs.selection[i]))
-                             *active_pcr |= hash_mask;
-             } else {
-                     EFI_PRINT("Unknown algorithm %x\n", pcrs.selection[i].hash);
-             }
-     }
-
-     *pcr_banks = pcrs.count;
-
-     return 0;
-out:
-     return -1;
-}
-
-/**
- * __get_active_pcr_banks() - returns the currently active PCR banks
- *
- * @active_pcr_banks:                pointer for receiving the bitmap of currently
- *                           active PCR banks
- *
- * Return:   status code
- */
-static efi_status_t __get_active_pcr_banks(u32 *active_pcr_banks)
-{
-     struct udevice *dev;
-     u32 active = 0, supported = 0, pcr_banks = 0;
-     efi_status_t ret;
-     int err;
-
-     ret = platform_get_tpm2_device(&dev);
-     if (ret != EFI_SUCCESS)
-             goto out;
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_banks);
-     if (err) {
-             ret = EFI_DEVICE_ERROR;
-             goto out;
-     }
-
-     *active_pcr_banks = active;
-
-out:
-     return ret;
-}
-
-/* tcg2_create_digest - create a list of digests of the supported PCR banks
- *                   for a given memory range
- *
- * @input:           input memory
- * @length:          length of buffer to calculate the digest
- * @digest_list:     list of digests to fill in
- *
- * Return:           status code
- */
-static efi_status_t tcg2_create_digest(const u8 *input, u32 length,
-                                    struct tpml_digest_values *digest_list)
-{
-     sha1_context ctx;
-     sha256_context ctx_256;
-     sha512_context ctx_512;
-     u8 final[TPM2_SHA512_DIGEST_SIZE];
-     efi_status_t ret;
-     u32 active;
-     size_t i;
-
-     ret = __get_active_pcr_banks(&active);
-     if (ret != EFI_SUCCESS)
-             return ret;
-
-     digest_list->count = 0;
-     for (i = 0; i < MAX_HASH_COUNT; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
-
-             if (!(active & alg_to_mask(hash_alg)))
-                     continue;
-             switch (hash_alg) {
-             case TPM2_ALG_SHA1:
-                     sha1_starts(&ctx);
-                     sha1_update(&ctx, input, length);
-                     sha1_finish(&ctx, final);
-                     break;
-             case TPM2_ALG_SHA256:
-                     sha256_starts(&ctx_256);
-                     sha256_update(&ctx_256, input, length);
-                     sha256_finish(&ctx_256, final);
-                     break;
-             case TPM2_ALG_SHA384:
-                     sha384_starts(&ctx_512);
-                     sha384_update(&ctx_512, input, length);
-                     sha384_finish(&ctx_512, final);
-                     break;
-             case TPM2_ALG_SHA512:
-                     sha512_starts(&ctx_512);
-                     sha512_update(&ctx_512, input, length);
-                     sha512_finish(&ctx_512, final);
-                     break;
-             default:
-                     EFI_PRINT("Unsupported algorithm %x\n", hash_alg);
-                     return EFI_INVALID_PARAMETER;
-             }
-             digest_list->digests[digest_list->count].hash_alg = hash_alg;
-             memcpy(&digest_list->digests[digest_list->count].digest, final,
-                    (u32)alg_to_len(hash_alg));
-             digest_list->count++;
-     }
-
-     return EFI_SUCCESS;
-}
-
  /**
   * efi_tcg2_get_capability() - protocol capability information and state information
   *
@@ -759,7 +258,7 @@ efi_tcg2_get_capability(struct efi_tcg2_protocol *this,
       capability->protocol_version.major = 1;
       capability->protocol_version.minor = 1;
 
-     efi_ret = platform_get_tpm2_device(&dev);
+     efi_ret = tcg2_platform_get_tpm2(&dev);
       if (efi_ret != EFI_SUCCESS) {
               capability->supported_event_logs = 0;
               capability->hash_algorithm_bitmap = 0;
@@ -855,7 +354,7 @@ efi_tcg2_get_eventlog(struct efi_tcg2_protocol *this,
               goto out;
       }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
       if (ret != EFI_SUCCESS) {
               event_log_location = NULL;
               event_log_last_entry = NULL;
@@ -890,6 +389,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
       struct efi_image_regions *regs = NULL;
       void *new_efi = NULL;
       u8 hash[TPM2_SHA512_DIGEST_SIZE];
+     struct udevice *dev;
       efi_status_t ret;
       u32 active;
       int i;
@@ -905,16 +405,20 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
               goto out;
       }
 
-     ret = __get_active_pcr_banks(&active);
+     ret = tcg2_platform_get_tpm2(&dev);
+     if (ret != EFI_SUCCESS)
+             goto out;
+
+     ret = tcg2_get_active_pcr_banks(dev, &active);
       if (ret != EFI_SUCCESS) {
               goto out;
       }
 
       digest_list->count = 0;
-     for (i = 0; i < MAX_HASH_COUNT; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
+     for (i = 0; i < ARRAY_SIZE(tpm2_supported_algorithms); i++) {
+             u16 hash_alg = tpm2_supported_algorithms[i];
 
-             if (!(active & alg_to_mask(hash_alg)))
+             if (!(active & tpm2_algorithm_to_mask(hash_alg)))
                       continue;
               switch (hash_alg) {
               case TPM2_ALG_SHA1:
@@ -935,7 +439,7 @@ static efi_status_t tcg2_hash_pe_image(void *efi, u64 efi_size,
               }
               digest_list->digests[digest_list->count].hash_alg = hash_alg;
               memcpy(&digest_list->digests[digest_list->count].digest, hash,
-                    (u32)alg_to_len(hash_alg));
+                    (u32)tpm2_algorithm_to_len(hash_alg));
               digest_list->count++;
       }
 
@@ -975,7 +479,7 @@ efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size,
       if (!is_tcg2_protocol_installed())
               return EFI_SUCCESS;
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
       if (ret != EFI_SUCCESS)
               return EFI_SECURITY_VIOLATION;
 
@@ -1084,7 +588,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
               goto out;
       }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
       if (ret != EFI_SUCCESS)
               goto out;
 
@@ -1119,7 +623,7 @@ efi_tcg2_hash_log_extend_event(struct efi_tcg2_protocol *this, u64 flags,
               ret = tcg2_hash_pe_image((void *)(uintptr_t)data_to_hash,
                                        data_to_hash_len, &digest_list);
       } else {
-             ret = tcg2_create_digest((u8 *)(uintptr_t)data_to_hash,
+             ret = tcg2_create_digest(dev, (u8 *)(uintptr_t)data_to_hash,
                                        data_to_hash_len, &digest_list);
       }
 
@@ -1182,7 +686,7 @@ efi_tcg2_submit_command(struct efi_tcg2_protocol *this,
               goto out;
       }
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
       if (ret != EFI_SUCCESS)
               goto out;
 
@@ -1211,6 +715,7 @@ static efi_status_t EFIAPI
  efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
                             u32 *active_pcr_banks)
  {
+     struct udevice *dev;
       efi_status_t ret;
 
       if (!this || !active_pcr_banks) {
@@ -1218,8 +723,12 @@ efi_tcg2_get_active_pcr_banks(struct efi_tcg2_protocol *this,
               goto out;
       }
 
+     ret = tcg2_platform_get_tpm2(&dev);
+     if (ret != EFI_SUCCESS)
+             goto out;
+
       EFI_ENTRY("%p, %p", this, active_pcr_banks);
-     ret = __get_active_pcr_banks(active_pcr_banks);
+     ret = tcg2_get_active_pcr_banks(dev, active_pcr_banks);
 
  out:
       return EFI_EXIT(ret);
@@ -1270,397 +779,6 @@ static const struct efi_tcg2_protocol efi_tcg2_protocol = {
       .get_result_of_set_active_pcr_banks = efi_tcg2_get_result_of_set_active_pcr_banks,
  };
 
-/**
- * parse_event_log_header() -  Parse and verify the event log header fields
- *
- * @buffer:                  Pointer to the start of the eventlog
- * @size:                    Size of the eventlog
- * @pos:                     Return offset of the next event in buffer right
- *                           after the event header i.e specID
- *
- * Return:   status code
- */
-static efi_status_t parse_event_log_header(void *buffer, u32 size, u32 *pos)
-{
-     struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-     int i = 0;
-
-     if (size < sizeof(*event_header))
-             return EFI_COMPROMISED_DATA;
-
-     if (get_unaligned_le32(&event_header->pcr_index) != 0 ||
-         get_unaligned_le32(&event_header->event_type) != EV_NO_ACTION)
-             return EFI_COMPROMISED_DATA;
-
-     for (i = 0; i < sizeof(event_header->digest); i++) {
-             if (event_header->digest[i])
-                     return EFI_COMPROMISED_DATA;
-     }
-
-     *pos += sizeof(*event_header);
-
-     return EFI_SUCCESS;
-}
-
-/**
- * parse_specid_event() -  Parse and verify the specID Event in the eventlog
- *
- * @dev:             udevice
- * @buffer:          Pointer to the start of the eventlog
- * @log_size:                Size of the eventlog
- * @pos:             [in] Offset of specID event in the eventlog buffer
- *                   [out] Return offset of the next event in the buffer
- *                   after the specID
- * @digest_list:     list of digests in the event
- *
- * Return:           status code
- * @pos                      Offset in the eventlog where the specID event ends
- * @digest_list:     list of digests in the event
- */
-static efi_status_t parse_specid_event(struct udevice *dev, void *buffer,
-                                    u32 log_size, u32 *pos,
-                                    struct tpml_digest_values *digest_list)
-{
-     struct tcg_efi_spec_id_event *spec_event;
-     struct tcg_pcr_event *event_header = (struct tcg_pcr_event *)buffer;
-     size_t spec_event_size;
-     u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-     u32 spec_active = 0;
-     u16 hash_alg;
-     u8 vendor_sz;
-     int err, i;
-
-     if (*pos >= log_size || (*pos + sizeof(*spec_event)) > log_size)
-             return EFI_COMPROMISED_DATA;
-
-     /* Check specID event data */
-     spec_event = (struct tcg_efi_spec_id_event *)((uintptr_t)buffer + *pos);
-     /* Check for signature */
-     if (memcmp(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-                sizeof(TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03))) {
-             log_err("specID Event: Signature mismatch\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     if (spec_event->spec_version_minor !=
-                     TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2 ||
-         spec_event->spec_version_major !=
-                     TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2)
-             return EFI_COMPROMISED_DATA;
-
-     if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-         spec_event->number_of_algorithms < 1) {
-             log_err("specID Event: Number of algorithms incorrect\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     alg_count = spec_event->number_of_algorithms;
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-     if (err)
-             return EFI_DEVICE_ERROR;
-
-     digest_list->count = 0;
-     /*
-      * We have to take care that the sequence of algorithms that we record
-      * in digest_list matches the sequence in eventlog.
-      */
-     for (i = 0; i < alg_count; i++) {
-             hash_alg =
-               get_unaligned_le16(&spec_event->digest_sizes[i].algorithm_id);
-
-             if (!(supported & alg_to_mask(hash_alg))) {
-                     log_err("specID Event: Unsupported algorithm\n");
-                     return EFI_COMPROMISED_DATA;
-             }
-             digest_list->digests[digest_list->count++].hash_alg = hash_alg;
-
-             spec_active |= alg_to_mask(hash_alg);
-     }
-
-     /*
-      * TCG specification expects the event log to have hashes for all
-      * active PCR's
-      */
-     if (spec_active != active) {
-             /*
-              * Previous stage bootloader should know all the active PCR's
-              * and use them in the Eventlog.
-              */
-             log_err("specID Event: All active hash alg not present\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     /*
-      * the size of the spec event and placement of vendor_info_size
-      * depends on supported algoriths
-      */
-     spec_event_size =
-             offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-             alg_count * sizeof(spec_event->digest_sizes[0]);
-
-     if (*pos + spec_event_size >= log_size)
-             return EFI_COMPROMISED_DATA;
-
-     vendor_sz = *(uint8_t *)((uintptr_t)buffer + *pos + spec_event_size);
-
-     spec_event_size += sizeof(vendor_sz) + vendor_sz;
-     *pos += spec_event_size;
-
-     if (get_unaligned_le32(&event_header->event_size) != spec_event_size) {
-             log_err("specID event: header event size mismatch\n");
-             /* Right way to handle this can be to call SetActive PCR's */
-             return EFI_COMPROMISED_DATA;
-     }
-
-     return EFI_SUCCESS;
-}
-
-/**
- * tcg2_parse_event() -  Parse the event in the eventlog
- *
- * @dev:             udevice
- * @buffer:          Pointer to the start of the eventlog
- * @log_size:                Size of the eventlog
- * @offset:          [in] Offset of the event in the eventlog buffer
- *                   [out] Return offset of the next event in the buffer
- * @digest_list:     list of digests in the event
- * @pcr                      Index of the PCR in the event
- *
- * Return:           status code
- */
-static efi_status_t tcg2_parse_event(struct udevice *dev, void *buffer,
-                                  u32 log_size, u32 *offset,
-                                  struct tpml_digest_values *digest_list,
-                                  u32 *pcr)
-{
-     struct tcg_pcr_event2 *event = NULL;
-     u32 count, size, event_size;
-     size_t pos;
-
-     event_size = tcg_event_final_size(digest_list);
-     if (*offset >= log_size || *offset + event_size > log_size) {
-             log_err("Event exceeds log size\n");
-             return EFI_COMPROMISED_DATA;
-     }
-
-     event = (struct tcg_pcr_event2 *)((uintptr_t)buffer + *offset);
-     *pcr = get_unaligned_le32(&event->pcr_index);
-
-     /* get the count */
-     count = get_unaligned_le32(&event->digests.count);
-     if (count != digest_list->count)
-             return EFI_COMPROMISED_DATA;
-
-     pos = offsetof(struct tcg_pcr_event2, digests);
-     pos += offsetof(struct tpml_digest_values, digests);
-
-     for (int i = 0; i < digest_list->count; i++) {
-             u16 alg;
-             u16 hash_alg = digest_list->digests[i].hash_alg;
-             u8 *digest = (u8 *)&digest_list->digests[i].digest;
-
-             alg = get_unaligned_le16((void *)((uintptr_t)event + pos));
-
-             if (alg != hash_alg)
-                     return EFI_COMPROMISED_DATA;
-
-             pos += offsetof(struct tpmt_ha, digest);
-             memcpy(digest, (void *)((uintptr_t)event + pos), alg_to_len(hash_alg));
-             pos += alg_to_len(hash_alg);
-     }
-
-     size = get_unaligned_le32((void *)((uintptr_t)event + pos));
-     event_size += size;
-     pos += sizeof(u32); /* tcg_pcr_event2 event_size*/
-     pos += size;
-
-     /* make sure the calculated buffer is what we checked against */
-     if (pos != event_size)
-             return EFI_COMPROMISED_DATA;
-
-     if (pos > log_size)
-             return EFI_COMPROMISED_DATA;
-
-     *offset += pos;
-
-     return EFI_SUCCESS;
-}
-
-/**
- * tcg2_get_fw_eventlog() -  Get the eventlog address and size
- *
- * If the previous firmware has passed some eventlog, this function get it's
- * location and check for it's validity.
- *
- * @dev:             udevice
- * @log_buffer:              eventlog address
- * @log_sz:          eventlog size
- *
- * Return:   status code
- */
-static efi_status_t tcg2_get_fw_eventlog(struct udevice *dev, void *log_buffer,
-                                      size_t *log_sz)
-{
-     struct tpml_digest_values digest_list;
-     void *buffer;
-     efi_status_t ret;
-     u32 pcr, pos;
-     u64 base;
-     u32 sz;
-     bool extend_pcr = false;
-     int i;
-
-     ret = platform_get_eventlog(dev, &base, &sz);
-     if (ret != EFI_SUCCESS)
-             return ret;
-
-     if (sz > TPM2_EVENT_LOG_SIZE)
-             return EFI_VOLUME_FULL;
-
-     buffer = (void *)(uintptr_t)base;
-     pos = 0;
-     /* Parse the eventlog to check for its validity */
-     ret = parse_event_log_header(buffer, sz, &pos);
-     if (ret)
-             return ret;
-
-     ret = parse_specid_event(dev, buffer, sz, &pos, &digest_list);
-     if (ret) {
-             log_err("Error parsing SPEC ID Event\n");
-             return ret;
-     }
-
-     ret = tcg2_pcr_read(dev, 0, &digest_list);
-     if (ret) {
-             log_err("Error reading PCR 0\n");
-             return ret;
-     }
-
-     /*
-      * If PCR0 is 0, previous firmware didn't have the capability
-      * to extend the PCR. In this scenario, extend the PCR as
-      * the eventlog is parsed.
-      */
-     for (i = 0; i < digest_list.count; i++) {
-             u8 hash_buf[TPM2_SHA512_DIGEST_SIZE] = { 0 };
-             u16 hash_alg = digest_list.digests[i].hash_alg;
-
-             if (!memcmp((u8 *)&digest_list.digests[i].digest, hash_buf,
-                         alg_to_len(hash_alg)))
-                     extend_pcr = true;
-     }
-
-     while (pos < sz) {
-             ret = tcg2_parse_event(dev, buffer, sz, &pos, &digest_list,
-                                    &pcr);
-             if (ret) {
-                     log_err("Error parsing event\n");
-                     return ret;
-             }
-             if (extend_pcr) {
-                     ret = tcg2_pcr_extend(dev, pcr, &digest_list);
-                     if (ret != EFI_SUCCESS) {
-                             log_err("Error in extending PCR\n");
-                             return ret;
-                     }
-
-                     /* Clear the digest for next event */
-                     for (i = 0; i < digest_list.count; i++) {
-                             u16 hash_alg = digest_list.digests[i].hash_alg;
-                             u8 *digest =
-                                (u8 *)&digest_list.digests[i].digest;
-
-                             memset(digest, 0, alg_to_len(hash_alg));
-                     }
-             }
-     }
-
-     memcpy(log_buffer, buffer, sz);
-     *log_sz = sz;
-
-     return ret;
-}
-
-/**
- * create_specid_event() - Create the first event in the eventlog
- *
- * @dev:                     tpm device
- * @event_header:            Pointer to the final event header
- * @event_size:                      final spec event size
- *
- * Return:   status code
- */
-static efi_status_t create_specid_event(struct udevice *dev, void *buffer,
-                                     size_t *event_size)
-{
-     struct tcg_efi_spec_id_event *spec_event;
-     size_t spec_event_size;
-     efi_status_t ret = EFI_DEVICE_ERROR;
-     u32 active = 0, supported = 0, pcr_count = 0, alg_count = 0;
-     int err;
-     size_t i;
-
-     /*
-      * Create Spec event. This needs to be the first event in the log
-      * according to the TCG EFI protocol spec
-      */
-
-     /* Setup specID event data */
-     spec_event = (struct tcg_efi_spec_id_event *)buffer;
-     memcpy(spec_event->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE_03,
-            sizeof(spec_event->signature));
-     put_unaligned_le32(0, &spec_event->platform_class); /* type client */
-     spec_event->spec_version_minor =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MINOR_TPM2;
-     spec_event->spec_version_major =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_MAJOR_TPM2;
-     spec_event->spec_errata =
-             TCG_EFI_SPEC_ID_EVENT_SPEC_VERSION_ERRATA_TPM2;
-     spec_event->uintn_size = sizeof(efi_uintn_t) / sizeof(u32);
-
-     err = tpm2_get_pcr_info(dev, &supported, &active, &pcr_count);
-
-     if (err)
-             goto out;
-
-     for (i = 0; i < pcr_count; i++) {
-             u16 hash_alg = hash_algo_list[i].hash_alg;
-             u16 hash_len = hash_algo_list[i].hash_len;
-
-             if (active & alg_to_mask(hash_alg)) {
-                     put_unaligned_le16(hash_alg,
-                                        &spec_event->digest_sizes[alg_count].algorithm_id);
-                     put_unaligned_le16(hash_len,
-                                        &spec_event->digest_sizes[alg_count].digest_size);
-                     alg_count++;
-             }
-     }
-
-     spec_event->number_of_algorithms = alg_count;
-     if (spec_event->number_of_algorithms > MAX_HASH_COUNT ||
-         spec_event->number_of_algorithms < 1)
-             goto out;
-
-     /*
-      * the size of the spec event and placement of vendor_info_size
-      * depends on supported algoriths
-      */
-     spec_event_size =
-             offsetof(struct tcg_efi_spec_id_event, digest_sizes) +
-             spec_event->number_of_algorithms * sizeof(spec_event->digest_sizes[0]);
-     /* no vendor info for us */
-     memset(buffer + spec_event_size, 0, 1);
-     /* add a byte for vendor_info_size in the spec event */
-     spec_event_size += 1;
-     *event_size = spec_event_size;
-
-     return EFI_SUCCESS;
-
-out:
-     return ret;
-}
-
  /**
   * tcg2_uninit - remove the final event table and free efi memory on failures
   */
@@ -1722,7 +840,7 @@ out:
  }
 
  /**
- * tcg2_measure_event() - common function to add event log and extend PCR
+ * measure_event() - common function to add event log and extend PCR
   *
   * @dev:             TPM device
   * @pcr_index:               PCR index
@@ -1732,14 +850,13 @@ out:
   *
   * Return:   status code
   */
-static efi_status_t
-tcg2_measure_event(struct udevice *dev, u32 pcr_index, u32 event_type,
-                u32 size, u8 event[])
+static efi_status_t measure_event(struct udevice *dev, u32 pcr_index,
+                               u32 event_type, u32 size, u8 event[])
  {
       struct tpml_digest_values digest_list;
       efi_status_t ret;
 
-     ret = tcg2_create_digest(event, size, &digest_list);
+     ret = tcg2_create_digest(dev, event, size, &digest_list);
       if (ret != EFI_SUCCESS)
               goto out;
 
@@ -1766,9 +883,8 @@ static efi_status_t efi_append_scrtm_version(struct udevice *dev)
  {
       efi_status_t ret;
 
-     ret = tcg2_measure_event(dev, 0, EV_S_CRTM_VERSION,
-                              strlen(version_string) + 1,
-                              (u8 *)version_string);
+     ret = measure_event(dev, 0, EV_S_CRTM_VERSION,
+                         strlen(version_string) + 1, (u8 *)version_string);
 
       return ret;
  }
@@ -1784,12 +900,11 @@ static efi_status_t efi_init_event_log(void)
        * vendor_info_size is currently set to 0, we need to change the length
        * and allocate the flexible array member if this changes
        */
-     struct tcg_pcr_event *event_header = NULL;
+     struct tcg2_event_log elog;
       struct udevice *dev;
-     size_t spec_event_size;
       efi_status_t ret;
 
-     ret = platform_get_tpm2_device(&dev);
+     ret = tcg2_platform_get_tpm2(&dev);
       if (ret != EFI_SUCCESS)
               return ret;
 
@@ -1808,7 +923,6 @@ static efi_status_t efi_init_event_log(void)
        * The log header is defined to be in SHA1 event log entry format.
        * Setup event header
        */
-     event_header =  (struct tcg_pcr_event *)event_log.buffer;
       event_log.pos = 0;
       event_log.last_event_size = 0;
       event_log.get_event_called = false;

lib/efi_loader/efi_tcg2.c static efi_status_t efi_init_event_log(void) · line 938

Quoted 7 lines
lib/efi_loader/efi_tcg2.c +3 -1
@@ -1819,34 +933,19 @@ static efi_status_t efi_init_event_log(void)
        * Check if earlier firmware have passed any eventlog. Different
        * platforms can use different ways to do so.
        */
-     ret = tcg2_get_fw_eventlog(dev, event_log.buffer, &event_log.pos);
+     ret = tcg2_init_log(dev, &elog);
+     if (ret != EFI_SUCCESS)
+             goto free_pool;

So I think this is the last bit we need to change in order to support EFI properly. I read the email regarding the newly added reserved memory memory to the TPM node and it's fine, but that won't work for the existing U-Boot dtbs. Since this was working out of the box, I'd still prefer to keep that working even if that entry is missing.

If you look at this function, there is an efi_allocate_pool() call a few lines above. What this does is allocate the EventLog memory for EFI. Note here that this *has* to be EFI memory since the kernel's efi-stub can still call into the firmware (and in fact it does, that's who we measure the initrd in > 5.18 kernels). After the allocation it looks for those DT entries, and if tpm_event_log_addr is found it parses the EventLog and
1. Extends the PCRs
2. Adds the events into the Eventlog

Quoted 6 lines

The reason for that is that TF-A (the Arm first stage boot loader), doesn't have any TPM drivers. So U-Boot is trying to be 'smart' here. We are grabbing the EventLog from the previous bootloader and if PCR0!=0 we replay that into the hardware and re-create the EventLog.

[...]

This will fix the protocol installation, however there's still still something missing on the EFI side, since reading the eventlog fails with

tpm2_eventlog /sys/kernel/security/tpm0/binary_bios_measurements
version: 1
events:
ERROR: failed to parse tpm2 eventlog
ERROR: Unable to run tpm2_eventlog
But at least the kernel can find the EFI config tables properly. Also, note that the ret is efi_status_t and the new function you added returns an int. Just switch the ret here accordingly.

          * platforms can use different ways to do so.
          */
         ret = tcg2_init_log(dev, &elog);
(quoted diff) +4 -5
-       if (ret != EFI_SUCCESS)
-               goto free_pool;
-
-       memcpy(event_log.buffer, elog.log, elog.log_position);
-       event_log.pos = elog.log_position;
+       if (ret == EFI_SUCCESS) {
+               memcpy(event_log.buffer, elog.log, elog.log_position);
+               event_log.pos = elog.log_position;
+       }
Quoted 3 lines
Quoted 1 line

I'll try digging into the EFI issues more once I get some time

Ok Ignore the previous mail. I just noticed that the specid event is generated by tcg2_log_init() and that's where the errors come from.

OK, I think I understand the problem. One problem with your solution below is that it's only useful for EFI; writing the event log to a temporary buffer in the non-EFI case is a waste of time, since it can't go anywhere. I have a solution where the user can pass in their buffer in the tcg2_event_log structure in the event that no memory region is discovered. EFI can use that path.

Thanks for the debugging effort!

Eddie

Quoted 40 lines

So something like the *really ugly hack* fixes EFI. Can you please turn it into human-readable code

  #include <linux/unaligned/be_byteshift.h>
  #include <linux/unaligned/generic.h>
  #include <linux/unaligned/le_byteshift.h>
lib/tpm-v2.c +2 -1
+#include <malloc.h>
 
  #include "tpm-utils.h"
@@ -634,7 +635,7 @@ __weak int tcg2_platform_get_log(struct udevice
 *dev, void **addr, u32 *size)
 
                 if (dev_read_phandle_with_args(dev, "memory-region", NULL, 0,
                                                0, &args))
-                       return -ENODEV;
+                       goto alloc;
 
                 a = ofnode_get_addr_size(args.node, "reg", &s);
                 if (a == FDT_ADDR_T_NONE)
(quoted diff) +3 -0
@@ -643,6 +644,9 @@ __weak int tcg2_platform_get_log(struct udevice
 *dev, void **addr, u32 *size)
                 *addr = map_physmem(a, s, MAP_NOCACHE);
                 *size = (u32)s;
         }
+alloc:
+       *addr = calloc(1, 4096);
+       *size = 4096;
 
         return 0;
  }

Cheers
/Ilias

Quoted 4 lines

Cheers
/Ilias

Quoted 2 lines

Thanks!
/Ilias

#8 lore raw

Hi Eddie,

[...]

Quoted 19 lines
Quoted 19 lines

But at least the kernel can find the EFI config tables properly.

Quoted 18 lines

Also, note that the ret is efi_status_t and the new function you added returns an int. Just switch the ret here accordingly.

          * platforms can use different ways to do so.
          */
         ret = tcg2_init_log(dev, &elog);
(quoted diff) +4 -5
-       if (ret != EFI_SUCCESS)
-               goto free_pool;
-
-       memcpy(event_log.buffer, elog.log, elog.log_position);
-       event_log.pos = elog.log_position;
+       if (ret == EFI_SUCCESS) {
+               memcpy(event_log.buffer, elog.log, elog.log_position);
+               event_log.pos = elog.log_position;
+       }
Quoted 8 lines
Quoted 3 lines
Quoted 1 line

I'll try digging into the EFI issues more once I get some time

Ok Ignore the previous mail. I just noticed that the specid event is generated by tcg2_log_init() and that's where the errors come from.

OK, I think I understand the problem. One problem with your solution below is that it's only useful for EFI; writing the event log to a temporary buffer in the non-EFI case is a waste of time, since it can't go anywhere.

It's not even a 'solution', it's just an ugly hack to help you understand where things go sideways.

Quoted 4 lines

I have a solution where the user can pass in their buffer in the tcg2_event_log structure in the event that no memory region is discovered. EFI can use that path.

Yep that sounds sane, that way EFI can pass the efi allocated memory and you can call call that with NULL for non-efi code.
Please keep in mind that the EventLog, if it comes from TF-A, needs to be replayed into hardware as well, since TF-A doesn't extend PCRs.

Quoted 3 lines

Thanks for the debugging effort!

yw

Cheers
/Ilias

Quoted 44 lines

Eddie

Quoted 40 lines

So something like the *really ugly hack* fixes EFI. Can you please turn it into human-readable code

  #include <linux/unaligned/be_byteshift.h>
  #include <linux/unaligned/generic.h>
  #include <linux/unaligned/le_byteshift.h>
lib/tpm-v2.c +2 -1
+#include <malloc.h>
 
  #include "tpm-utils.h"
@@ -634,7 +635,7 @@ __weak int tcg2_platform_get_log(struct udevice
 *dev, void **addr, u32 *size)
 
                 if (dev_read_phandle_with_args(dev, "memory-region", NULL, 0,
                                                0, &args))
-                       return -ENODEV;
+                       goto alloc;
 
                 a = ofnode_get_addr_size(args.node, "reg", &s);
                 if (a == FDT_ADDR_T_NONE)
(quoted diff) +3 -0
@@ -643,6 +644,9 @@ __weak int tcg2_platform_get_log(struct udevice
 *dev, void **addr, u32 *size)
                 *addr = map_physmem(a, s, MAP_NOCACHE);
                 *size = (u32)s;
         }
+alloc:
+       *addr = calloc(1, 4096);
+       *size = 4096;
 
         return 0;
  }

Cheers
/Ilias

Quoted 4 lines

Cheers
/Ilias

Quoted 2 lines

Thanks!
/Ilias

#9 lore raw

Hi Eddie,
One last thing...
Since you'll send a v7, mind adding the Linaro copyright on tpm-v2.c since it's mostly my code moving around wrt to the TCG stuff?

Cheers
/Ilias

Quoted 98 lines · Ilias Apalodimas

Hi Eddie,

[...]

Quoted 19 lines
Quoted 19 lines

But at least the kernel can find the EFI config tables properly.

Quoted 18 lines

Also, note that the ret is efi_status_t and the new function you added returns an int. Just switch the ret here accordingly.

          * platforms can use different ways to do so.
          */
         ret = tcg2_init_log(dev, &elog);
(quoted diff) +4 -5
-       if (ret != EFI_SUCCESS)
-               goto free_pool;
-
-       memcpy(event_log.buffer, elog.log, elog.log_position);
-       event_log.pos = elog.log_position;
+       if (ret == EFI_SUCCESS) {
+               memcpy(event_log.buffer, elog.log, elog.log_position);
+               event_log.pos = elog.log_position;
+       }
Quoted 8 lines
Quoted 3 lines
Quoted 1 line

I'll try digging into the EFI issues more once I get some time

Ok Ignore the previous mail. I just noticed that the specid event is generated by tcg2_log_init() and that's where the errors come from.

OK, I think I understand the problem. One problem with your solution below is that it's only useful for EFI; writing the event log to a temporary buffer in the non-EFI case is a waste of time, since it can't go anywhere.

It's not even a 'solution', it's just an ugly hack to help you understand where things go sideways.

Quoted 4 lines

I have a solution where the user can pass in their buffer in the tcg2_event_log structure in the event that no memory region is discovered. EFI can use that path.

Yep that sounds sane, that way EFI can pass the efi allocated memory and you can call call that with NULL for non-efi code.
Please keep in mind that the EventLog, if it comes from TF-A, needs to be replayed into hardware as well, since TF-A doesn't extend PCRs.

Quoted 3 lines

Thanks for the debugging effort!

yw

Cheers
/Ilias

Quoted 44 lines

Eddie

Quoted 40 lines

So something like the *really ugly hack* fixes EFI. Can you please turn it into human-readable code

  #include <linux/unaligned/be_byteshift.h>
  #include <linux/unaligned/generic.h>
  #include <linux/unaligned/le_byteshift.h>
lib/tpm-v2.c +2 -1
+#include <malloc.h>
 
  #include "tpm-utils.h"
@@ -634,7 +635,7 @@ __weak int tcg2_platform_get_log(struct udevice
 *dev, void **addr, u32 *size)
 
                 if (dev_read_phandle_with_args(dev, "memory-region", NULL, 0,
                                                0, &args))
-                       return -ENODEV;
+                       goto alloc;
 
                 a = ofnode_get_addr_size(args.node, "reg", &s);
                 if (a == FDT_ADDR_T_NONE)
(quoted diff) +3 -0
@@ -643,6 +644,9 @@ __weak int tcg2_platform_get_log(struct udevice
 *dev, void **addr, u32 *size)
                 *addr = map_physmem(a, s, MAP_NOCACHE);
                 *size = (u32)s;
         }
+alloc:
+       *addr = calloc(1, 4096);
+       *size = 4096;
 
         return 0;
  }

Cheers
/Ilias

Quoted 4 lines

Cheers
/Ilias

Quoted 2 lines

Thanks!
/Ilias

#10 lore raw

PATCH v6 4/6 bootm: Support boot measurement

In reply to Eddie James

Add a configuration option to measure the boot through the bootm function. Add the measurement state to the booti and bootz paths as well.

---
 boot/Kconfig    | 23 ++++++++++++++++
 boot/bootm.c    | 70 +++++++++++++++++++++++++++++++++++++++++++++++++
 cmd/booti.c     |  1 +
 cmd/bootm.c     |  2 ++
 cmd/bootz.c     |  1 +
 include/bootm.h |  2 ++
 include/image.h |  1 +
 7 files changed, 100 insertions(+)
boot/Kconfig +23 -0
index 5f491625c8..d0d5e5794c 100644
@@ -629,6 +629,29 @@ config LEGACY_IMAGE_FORMAT
 	  loaded. If a board needs the legacy image format support in this
 	  case, enable it here.
 
+config MEASURED_BOOT
+	bool "Measure boot images and configuration to TPM and event log"
+	depends on HASH && TPM_V2
+	help
+	  This option enables measurement of the boot process. Measurement
+	  involves creating cryptographic hashes of the binary images that
+	  are booting and storing them in the TPM. In addition, a log of
+	  these hashes is stored in memory for the OS to verify the booted
+	  images and configuration. Enable this if the OS has configured
+	  some memory area for the event log and you intend to use some
+	  attestation tools on your system.
+
+if MEASURED_BOOT
+	config MEASURE_DEVICETREE
+	bool "Measure the devicetree image"
+	default y if MEASURED_BOOT
+	help
+	  On some platforms, the devicetree is not static as it may contain
+	  random MAC addresses or other such data that changes each boot.
+	  Therefore, it should not be measured into the TPM. In that case,
+	  disable the measurement here.
+endif # MEASURED_BOOT
+
 config SUPPORT_RAW_INITRD
 	bool "Enable raw initrd images"
 	help
boot/bootm.c +70 -0

88 lines not on this page · raw message

cmd/booti.c +1 -0
index 6ac39193db..659bb10549 100644
@@ -127,6 +127,7 @@ int do_booti(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
 			      BOOTM_STATE_RAMDISK |
 #endif
+			      BOOTM_STATE_MEASURE |
 			      BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
 			      BOOTM_STATE_OS_GO,
 			      &images, 1);
cmd/bootm.c +2 -0
index 37c2af96e0..0c4a713e02 100644
@@ -161,6 +161,8 @@ int do_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		BOOTM_STATE_OS_GO;
 	if (IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH))
 		states |= BOOTM_STATE_RAMDISK;
+	if (IS_ENABLED(CONFIG_MEASURED_BOOT))
+		states |= BOOTM_STATE_MEASURE;
 	if (IS_ENABLED(CONFIG_PPC) || IS_ENABLED(CONFIG_MIPS))
 		states |= BOOTM_STATE_OS_CMDLINE;
 	ret = do_bootm_states(cmdtp, flag, argc, argv, states, &images, 1);
cmd/bootz.c +1 -0
index f1423573d2..87922bfc3c 100644
@@ -81,6 +81,7 @@ int do_bootz(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
 			      BOOTM_STATE_RAMDISK |
 #endif
+			      BOOTM_STATE_MEASURE |
 			      BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
 			      BOOTM_STATE_OS_GO,
 			      &images, 1);
include/bootm.h +2 -0
index 044a4797ed..06d8b1acd8 100644
@@ -55,6 +55,8 @@ ulong bootm_disable_interrupts(void);
 int bootm_find_images(int flag, int argc, char *const argv[], ulong start,
 		      ulong size);
 
+int bootm_measure(struct bootm_headers *images);
+
 int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
 		    char *const argv[], int states, struct bootm_headers *images,
 		    int boot_progress);
include/image.h +1 -0
index 7717a4c13d..f7414b5338 100644
@@ -407,6 +407,7 @@ struct bootm_headers {
 #define BOOTM_STATE_OS_FAKE_GO	0x00000200	/* 'Almost' run the OS */
 #define BOOTM_STATE_OS_GO	0x00000400
 #define BOOTM_STATE_PRE_LOAD	0x00000800
+#define BOOTM_STATE_MEASURE	0x00001000
 	int		state;
 
 #if defined(CONFIG_LMB) && !defined(USE_HOSTCC)
Signature · 1 line
2.31.1
Reviewed-by on v6 4/6
#11 lore raw

Re: [PATCH v6 4/6] bootm: Support boot measurement

Hi Eddie,

Quoted 6 lines · Eddie James

Add a configuration option to measure the boot through the bootm function. Add the measurement state to the booti and bootz paths as well.

Quoted 9 lines
---
 boot/Kconfig    | 23 ++++++++++++++++
 boot/bootm.c    | 70 +++++++++++++++++++++++++++++++++++++++++++++++++
 cmd/booti.c     |  1 +
 cmd/bootm.c     |  2 ++
 cmd/bootz.c     |  1 +
 include/bootm.h |  2 ++
 include/image.h |  1 +
 7 files changed, 100 insertions(+)
Quoted 121 lines
boot/Kconfig +23 -0
index 5f491625c8..d0d5e5794c 100644
@@ -629,6 +629,29 @@ config LEGACY_IMAGE_FORMAT
          loaded. If a board needs the legacy image format support in this
          case, enable it here.
 
+config MEASURED_BOOT
+       bool "Measure boot images and configuration to TPM and event log"
+       depends on HASH && TPM_V2
+       help
+         This option enables measurement of the boot process. Measurement
+         involves creating cryptographic hashes of the binary images that
+         are booting and storing them in the TPM. In addition, a log of
+         these hashes is stored in memory for the OS to verify the booted
+         images and configuration. Enable this if the OS has configured
+         some memory area for the event log and you intend to use some
+         attestation tools on your system.
+
+if MEASURED_BOOT
+       config MEASURE_DEVICETREE
+       bool "Measure the devicetree image"
+       default y if MEASURED_BOOT
+       help
+         On some platforms, the devicetree is not static as it may contain
+         random MAC addresses or other such data that changes each boot.
+         Therefore, it should not be measured into the TPM. In that case,
+         disable the measurement here.
+endif # MEASURED_BOOT
+
 config SUPPORT_RAW_INITRD
        bool "Enable raw initrd images"
        help
boot/bootm.c +67 -0
index 2eec60ec7b..10b4848c7e 100644
@@ -22,6 +22,7 @@
 #include <asm/global_data.h>
 #include <asm/io.h>
 #include <linux/sizes.h>
+#include <tpm-v2.h>
 #if defined(CONFIG_CMD_USB)
 #include <usb.h>
 #endif
@@ -659,6 +660,72 @@ int bootm_process_cmdline_env(int flags)
        return 0;
 }
 
+int bootm_measure(struct bootm_headers *images)
+{
+       int ret = 0;
+
+       /* Skip measurement if EFI is going to do it */
+       if (images->os.os == IH_OS_EFI &&
+           IS_ENABLED(CONFIG_EFI_TCG2_PROTOCOL) &&
+           IS_ENABLED(CONFIG_BOOTM_EFI))
+               return ret;
+
+       if (IS_ENABLED(CONFIG_MEASURED_BOOT)) {
+               struct tcg2_event_log elog;
+               struct udevice *dev;
+               void *initrd_buf;
+               void *image_buf;
+               const char *s;
+               u32 rd_len;
+
+               ret = tcg2_measurement_init(&dev, &elog);
+               if (ret)
+                       return ret;
+
+               image_buf = map_sysmem(images->os.image_start,
+                                      images->os.image_len);
+               ret = tcg2_measure_data(dev, &elog, 8, images->os.image_len,
+                                       image_buf, EV_COMPACT_HASH,
+                                       strlen("linux") + 1, (u8 *)"linux");
+               if (ret)
+                       goto unmap_image;
+
+               rd_len = images->rd_end - images->rd_start;
+               initrd_buf = map_sysmem(images->rd_start, rd_len);
+               ret = tcg2_measure_data(dev, &elog, 9, rd_len, initrd_buf,
+                                       EV_COMPACT_HASH, strlen("initrd") + 1,
+                                       (u8 *)"initrd");
+               if (ret)
+                       goto unmap_initrd;
+
+               if (IS_ENABLED(CONFIG_MEASURE_DEVICETREE)) {
+                       ret = tcg2_measure_data(dev, &elog, 0, images->ft_len,
+                                               (u8 *)images->ft_addr,
+                                               EV_TABLE_OF_DEVICES,
+                                               strlen("dts") + 1,
+                                               (u8 *)"dts");
+                       if (ret)
+                               goto unmap_initrd;
+               }
+
+               s = env_get("bootargs");
+               if (!s)
+                       s = "";
+               ret = tcg2_measure_data(dev, &elog, 1, strlen(s) + 1, (u8 *)s,
+                                       EV_PLATFORM_CONFIG_FLAGS,
+                                       strlen(s) + 1, (u8 *)s);
+
+unmap_initrd:
+               unmap_sysmem(initrd_buf);
+
+unmap_image:
+               unmap_sysmem(image_buf);
+               tcg2_measurement_term(dev, &elog, ret != 0);
+       }
+
+       return ret;
+}
+
 /**
  * Execute selected states of the bootm command.
  *

boot/bootm.c int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc, · line 780

Quoted 4 lines
boot/bootm.c +1 -0
@@ -710,6 +777,9 @@ int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
        if (!ret && (states & BOOTM_STATE_FINDOTHER))
                ret = bootm_find_other(cmdtp, flag, argc, argv);
 
+       if (IS_ENABLED(CONFIG_MEASURED_BOOT) && !ret && (states & BOOTM_STATE_MEASURE))

line length?

Quoted 47 lines
boot/bootm.c +2 -0
+               bootm_measure(images);
+
        /* Load the OS */
        if (!ret && (states & BOOTM_STATE_LOADOS)) {
                iflag = bootm_disable_interrupts();
cmd/booti.c +1 -0
index 6ac39193db..659bb10549 100644
@@ -127,6 +127,7 @@ int do_booti(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
                              BOOTM_STATE_RAMDISK |
 #endif
+                             BOOTM_STATE_MEASURE |
                              BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
                              BOOTM_STATE_OS_GO,
                              &images, 1);
cmd/bootm.c +2 -0
index 37c2af96e0..0c4a713e02 100644
@@ -161,6 +161,8 @@ int do_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
                BOOTM_STATE_OS_GO;
        if (IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH))
                states |= BOOTM_STATE_RAMDISK;
+       if (IS_ENABLED(CONFIG_MEASURED_BOOT))
+               states |= BOOTM_STATE_MEASURE;
        if (IS_ENABLED(CONFIG_PPC) || IS_ENABLED(CONFIG_MIPS))
                states |= BOOTM_STATE_OS_CMDLINE;
        ret = do_bootm_states(cmdtp, flag, argc, argv, states, &images, 1);
cmd/bootz.c +1 -0
index f1423573d2..87922bfc3c 100644
@@ -81,6 +81,7 @@ int do_bootz(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 #ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
                              BOOTM_STATE_RAMDISK |
 #endif
+                             BOOTM_STATE_MEASURE |
                              BOOTM_STATE_OS_PREP | BOOTM_STATE_OS_FAKE_GO |
                              BOOTM_STATE_OS_GO,
                              &images, 1);
include/bootm.h +0 -0
index 044a4797ed..06d8b1acd8 100644

include/bootm.h ulong bootm_disable_interrupts(void); · line 58

Quoted 4 lines
include/bootm.h +1 -0
@@ -55,6 +55,8 @@ ulong bootm_disable_interrupts(void);
 int bootm_find_images(int flag, int argc, char *const argv[], ulong start,
                      ulong size);
 
+int bootm_measure(struct bootm_headers *images);

please add a full comment for this, including what it actually does / 'measures' and what 'measure' means.

Quoted 17 lines
include/bootm.h +1 -0
+
 int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
                    char *const argv[], int states, struct bootm_headers *images,
                    int boot_progress);
include/image.h +1 -1
index 7717a4c13d..f7414b5338 100644
@@ -407,6 +407,7 @@ struct bootm_headers {
 #define BOOTM_STATE_OS_FAKE_GO 0x00000200      /* 'Almost' run the OS */
 #define BOOTM_STATE_OS_GO      0x00000400
 #define BOOTM_STATE_PRE_LOAD   0x00000800
+#define BOOTM_STATE_MEASURE    0x00001000
        int             state;
 
 #if defined(CONFIG_LMB) && !defined(USE_HOSTCC)
--
Quoted 2 lines

2.31.1

Regards,
Simon

#12 lore raw

PATCH v6 5/6 test: Add sandbox TPM boot measurement

In reply to Eddie James

Use the sandbox TPM driver to measure some boot images in a unit test case.

---
Changes since v5:
- Only compile in the measurement u-boot command when CONFIG_MEASURED_BOOT is enabled

 arch/sandbox/dts/sandbox.dtsi | 13 +++++++
 arch/sandbox/dts/test.dts     | 13 +++++++
 configs/sandbox_defconfig     |  1 +
 include/test/suites.h         |  1 +
 test/boot/Makefile            |  1 +
 test/boot/measurement.c       | 66 +++++++++++++++++++++++++++++++++++
 test/cmd_ut.c                 |  4 +++
 7 files changed, 99 insertions(+)
 create mode 100644 test/boot/measurement.c
arch/sandbox/dts/sandbox.dtsi +13 -0
index 7e7fcff6d2..3442be7634 100644
@@ -4,11 +4,23 @@
  * and sandbox64 builds.
  */
 
+#include <config.h>
 #include <dt-bindings/input/input.h>
 
 #define USB_CLASS_HUB			9
 
 / {
+	reserved-memory {
+		#address-cells = <1>;
+		#size-cells = <1>;
+		ranges;
+
+		event_log: tcg_event_log {
+			no-map;
+			reg = <(CFG_SYS_SDRAM_SIZE - 0x2000) 0x2000>;
+		};
+	};
+
 	binman {
 	};
 
@@ -336,6 +348,7 @@
 
 	tpm2 {
 		compatible = "sandbox,tpm2";
+		memory-region = <&event_log>;
 	};
 
 	triangle {
arch/sandbox/dts/test.dts +13 -0
index 9717103f10..7659effa71 100644
@@ -9,6 +9,7 @@
 
 /dts-v1/;
 
+#include <config.h>
 #include <dt-bindings/gpio/gpio.h>
 #include <dt-bindings/gpio/sandbox-gpio.h>
 #include <dt-bindings/input/input.h>
@@ -66,6 +67,17 @@
 		osd0 = "/osd";
 	};
 
+	reserved-memory {
+		#address-cells = <1>;
+		#size-cells = <1>;
+		ranges;
+
+		event_log: tcg_event_log {
+			no-map;
+			reg = <(CFG_SYS_SDRAM_SIZE - 0x2000) 0x2000>;
+		};
+	};
+
 	binman: binman {
 	};
 
@@ -1365,6 +1377,7 @@
 
 	tpm2 {
 		compatible = "sandbox,tpm2";
+		memory-region = <&event_log>;
 	};
 
 	tpm {
configs/sandbox_defconfig +1 -0
index 77ade1f1d8..43b15b8446 100644
@@ -335,3 +335,4 @@ CONFIG_TEST_FDTDEC=y
 CONFIG_UNIT_TEST=y
 CONFIG_UT_TIME=y
 CONFIG_UT_DM=y
+CONFIG_MEASURED_BOOT=y
include/test/suites.h +1 -0
index 7c4960c004..b552fea9a9 100644
@@ -44,6 +44,7 @@ int do_ut_font(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_lib(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_loadm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_log(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
+int do_ut_measurement(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
 int do_ut_mem(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_optee(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_overlay(struct cmd_tbl *cmdtp, int flag, int argc,
test/boot/Makefile +1 -0
index 22ed61c8fa..2dbb032a7e 100644
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_BOOTSTD) += bootdev.o bootstd_common.o bootflow.o bootmeth.o
 obj-$(CONFIG_FIT) += image.o
+obj-$(CONFIG_MEASURED_BOOT) += measurement.o
 
 obj-$(CONFIG_EXPO) += expo.o
 
test/boot/measurement.c new file +66 -0

66 lines not on this page · raw message

test/cmd_ut.c +4 -0
index 409c22bfd2..25b873d0ea 100644
@@ -96,6 +96,10 @@ static struct cmd_tbl cmd_ut_sub[] = {
 #if CONFIG_IS_ENABLED(UT_UNICODE) && !defined(API_BUILD)
 	U_BOOT_CMD_MKENT(unicode, CONFIG_SYS_MAXARGS, 1, do_ut_unicode, "", ""),
 #endif
+#ifdef CONFIG_MEASURED_BOOT
+	U_BOOT_CMD_MKENT(measurement, CONFIG_SYS_MAXARGS, 1, do_ut_measurement,
+			 "", ""),
+#endif
 #ifdef CONFIG_SANDBOX
 	U_BOOT_CMD_MKENT(compression, CONFIG_SYS_MAXARGS, 1, do_ut_compression,
 			 "", ""),
Signature · 1 line
2.31.1
Acked-by on v6 5/6
#13 lore raw

Re: [PATCH v6 5/6] test: Add sandbox TPM boot measurement

Quoted 216 lines · Eddie James

Use the sandbox TPM driver to measure some boot images in a unit test case.

---
Changes since v5:
- Only compile in the measurement u-boot command when CONFIG_MEASURED_BOOT is enabled

 arch/sandbox/dts/sandbox.dtsi | 13 +++++++
 arch/sandbox/dts/test.dts     | 13 +++++++
 configs/sandbox_defconfig     |  1 +
 include/test/suites.h         |  1 +
 test/boot/Makefile            |  1 +
 test/boot/measurement.c       | 66 +++++++++++++++++++++++++++++++++++
 test/cmd_ut.c                 |  4 +++
 7 files changed, 99 insertions(+)
 create mode 100644 test/boot/measurement.c
arch/sandbox/dts/sandbox.dtsi +13 -0
index 7e7fcff6d2..3442be7634 100644
@@ -4,11 +4,23 @@
  * and sandbox64 builds.
  */
 
+#include <config.h>
 #include <dt-bindings/input/input.h>
 
 #define USB_CLASS_HUB                  9
 
 / {
+       reserved-memory {
+               #address-cells = <1>;
+               #size-cells = <1>;
+               ranges;
+
+               event_log: tcg_event_log {
+                       no-map;
+                       reg = <(CFG_SYS_SDRAM_SIZE - 0x2000) 0x2000>;
+               };
+       };
+
        binman {
        };
 
@@ -336,6 +348,7 @@
 
        tpm2 {
                compatible = "sandbox,tpm2";
+               memory-region = <&event_log>;
        };
 
        triangle {
arch/sandbox/dts/test.dts +13 -0
index 9717103f10..7659effa71 100644
@@ -9,6 +9,7 @@
 
 /dts-v1/;
 
+#include <config.h>
 #include <dt-bindings/gpio/gpio.h>
 #include <dt-bindings/gpio/sandbox-gpio.h>
 #include <dt-bindings/input/input.h>
@@ -66,6 +67,17 @@
                osd0 = "/osd";
        };
 
+       reserved-memory {
+               #address-cells = <1>;
+               #size-cells = <1>;
+               ranges;
+
+               event_log: tcg_event_log {
+                       no-map;
+                       reg = <(CFG_SYS_SDRAM_SIZE - 0x2000) 0x2000>;
+               };
+       };
+
        binman: binman {
        };
 
@@ -1365,6 +1377,7 @@
 
        tpm2 {
                compatible = "sandbox,tpm2";
+               memory-region = <&event_log>;
        };
 
        tpm {
configs/sandbox_defconfig +1 -0
index 77ade1f1d8..43b15b8446 100644
@@ -335,3 +335,4 @@ CONFIG_TEST_FDTDEC=y
 CONFIG_UNIT_TEST=y
 CONFIG_UT_TIME=y
 CONFIG_UT_DM=y
+CONFIG_MEASURED_BOOT=y
include/test/suites.h +1 -0
index 7c4960c004..b552fea9a9 100644
@@ -44,6 +44,7 @@ int do_ut_font(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_lib(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_loadm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_log(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
+int do_ut_measurement(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
 int do_ut_mem(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_optee(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
 int do_ut_overlay(struct cmd_tbl *cmdtp, int flag, int argc,
test/boot/Makefile +1 -0
index 22ed61c8fa..2dbb032a7e 100644
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_BOOTSTD) += bootdev.o bootstd_common.o bootflow.o bootmeth.o
 obj-$(CONFIG_FIT) += image.o
+obj-$(CONFIG_MEASURED_BOOT) += measurement.o
 
 obj-$(CONFIG_EXPO) += expo.o
 
test/boot/measurement.c new file +66 -0
new file mode 100644
index 0000000000..9db2ed324c
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Test for measured boot functions
+ *
+ * Copyright 2023 IBM Corp.
+ * Written by Eddie James <[email protected]>
+ */
+
+#include <common.h>
+#include <bootm.h>
+#include <malloc.h>
+#include <test/suites.h>
+#include <test/test.h>
+#include <test/ut.h>
+#include <asm/io.h>
+
+#define MEASUREMENT_TEST(_name, _flags)        \
+       UNIT_TEST(_name, _flags, measurement_test)
+
+static int measure(struct unit_test_state *uts)
+{
+       struct bootm_headers images;
+       const size_t size = 1024;
+       u8 *kernel;
+       u8 *initrd;
+       size_t i;
+
+       kernel = malloc(size);
+       initrd = malloc(size);
+
+       images.os.image_start = map_to_sysmem(kernel);
+       images.os.image_len = size;
+
+       images.rd_start = map_to_sysmem(initrd);
+       images.rd_end = images.rd_start + size;
+
+       images.ft_addr = malloc(size);
+       images.ft_len = size;
+
+       env_set("bootargs", "measurement testing");
+
+       for (i = 0; i < size; ++i) {
+               kernel[i] = 0xf0 | (i & 0xf);
+               initrd[i] = (i & 0xf0) | 0xf;
+               images.ft_addr[i] = i & 0xff;
+       }
+
+       ut_assertok(bootm_measure(&images));
+
+       free(images.ft_addr);
+       free(initrd);
+       free(kernel);
+
+       return 0;
+}
+MEASUREMENT_TEST(measure, 0);
+
+int do_ut_measurement(struct cmd_tbl *cmdtp, int flag, int argc,
+                     char *const argv[])
+{
+       struct unit_test *tests = UNIT_TEST_SUITE_START(measurement_test);
+       const int n_ents = UNIT_TEST_SUITE_COUNT(measurement_test);
+
+       return cmd_ut_category("measurement", "measurement_test_", tests,
+                              n_ents, argc, argv);
+}
test/cmd_ut.c +4 -1
index 409c22bfd2..25b873d0ea 100644
@@ -96,6 +96,10 @@ static struct cmd_tbl cmd_ut_sub[] = {
 #if CONFIG_IS_ENABLED(UT_UNICODE) && !defined(API_BUILD)
        U_BOOT_CMD_MKENT(unicode, CONFIG_SYS_MAXARGS, 1, do_ut_unicode, "", ""),
 #endif
+#ifdef CONFIG_MEASURED_BOOT
+       U_BOOT_CMD_MKENT(measurement, CONFIG_SYS_MAXARGS, 1, do_ut_measurement,
+                        "", ""),
+#endif
 #ifdef CONFIG_SANDBOX
        U_BOOT_CMD_MKENT(compression, CONFIG_SYS_MAXARGS, 1, do_ut_compression,
                         "", ""),
--
Quoted 2 lines

2.31.1

#14 lore raw

PATCH v6 6/6 doc: Add measured boot documentation

In reply to Eddie James

Briefly describe the feature and specify the requirements.

---
 doc/usage/index.rst         |  1 +
 doc/usage/measured_boot.rst | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 doc/usage/measured_boot.rst
doc/usage/index.rst +1 -0
index cde7dcb14a..0cf78cb0e7 100644
@@ -12,6 +12,7 @@ Use U-Boot
    partitions
    cmdline
    semihosting
+   measured_boot
 
 Shell commands
 --------------
doc/usage/measured_boot.rst new file +23 -0
new file mode 100644
index 0000000000..8357b1f480
@@ -0,0 +1,23 @@
+.. SPDX-License-Identifier: GPL-2.0+
+
+Measured Boot
+=====================
+
+U-Boot can perform a measured boot, the process of hashing various components
+of the boot process, extending the results in the TPM and logging the
+component's measurement in memory for the operating system to consume.
+
+Requirements
+---------------------
+
+* A hardware TPM 2.0 supported by the U-Boot drivers
+* CONFIG_TPM=y
+* CONFIG_MEASURED_BOOT=y
+* Device-tree configuration of the TPM device to specify the memory area
+  for event logging. The TPM device node must either contain a phandle to
+  a reserved memory region or "linux,sml-base" and "linux,sml-size"
+  indicating the address and size of the memory region. An example can be
+  found in arch/sandbox/dts/test.dts
+* The operating system must also be configured to use the memory regions
+  specified in the U-Boot device-tree in order to make use of the event
+  log.
Signature · 1 line
2.31.1
Reviewed-by on v6 6/6
#15 lore raw

Re: [PATCH v6 6/6] doc: Add measured boot documentation

Quoted 9 lines · Eddie James

Briefly describe the feature and specify the requirements.

---
 doc/usage/index.rst         |  1 +
 doc/usage/measured_boot.rst | 23 +++++++++++++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 doc/usage/measured_boot.rst
#16 lore raw

Re: [PATCH v6 6/6] doc: Add measured boot documentation

In reply to Eddie James

Am 22. Februar 2023 19:02:42 MEZ schrieb Eddie James <[email protected]>:

Quoted 27 lines

Briefly describe the feature and specify the requirements.

---
doc/usage/index.rst | 1 +
doc/usage/measured_boot.rst | 23 +++++++++++++++++++++++

2 files changed, 24 insertions(+)

create mode 100644 doc/usage/measured_boot.rst

doc/usage/index.rst +1 -0
index cde7dcb14a..0cf78cb0e7 100644
@@ -12,6 +12,7 @@ Use U-Boot
   partitions
   cmdline
   semihosting
+   measured_boot
 

Shell commands
--------------

doc/usage/measured_boot.rst new file +0 -0
new file mode 100644
index 0000000000..8357b1f480

doc/usage/measured_boot.rst line 4

Quoted 4 lines
doc/usage/measured_boot.rst new file +4 -0
@@ -0,0 +1,23 @@
+.. SPDX-License-Identifier: GPL-2.0+
+
+Measured Boot
+=====================

This completely misses o describe measured boot with UEFI.

@Ilias, do you want to add that in a follow up patch?

Quoted 9 lines
doc/usage/measured_boot.rst new file +9 -0
+
+U-Boot can perform a measured boot, the process of hashing various components
+of the boot process, extending the results in the TPM and logging the
+component's measurement in memory for the operating system to consume.
+
+Requirements
+---------------------
+
+* A hardware TPM 2.0 supported by the U-Boot drivers

doc/usage/measured_boot.rst line 23

Quoted 10 lines
doc/usage/measured_boot.rst new file +10 -0
+* CONFIG_TPM=y
+* CONFIG_MEASURED_BOOT=y
+* Device-tree configuration of the TPM device to specify the memory area
+  for event logging. The TPM device node must either contain a phandle to
+  a reserved memory region or "linux,sml-base" and "linux,sml-size"
+  indicating the address and size of the memory region. An example can be
+  found in arch/sandbox/dts/test.dts
+* The operating system must also be configured to use the memory regions
+  specified in the U-Boot device-tree in order to make use of the event
+  log.

Please, provide enough information such that a reader can set this up. This should include example code.

Best regards

Heinrich

#17 lore raw

Re: [PATCH v6 6/6] doc: Add measured boot documentation

Hi Heinrich,

[...]

Quoted 7 lines

doc/usage/measured_boot.rst line 4

Quoted 3 lines
doc/usage/measured_boot.rst new file +3 -0
+
+Measured Boot
+=====================

This completely misses o describe measured boot with UEFI.

@Ilias, do you want to add that in a follow up patch?

Yes, I'll do that once I pull Eddie's patches

Cheers
/Ilias

Quoted 26 lines
Quoted 10 lines
doc/usage/measured_boot.rst new file +9 -0
+
+U-Boot can perform a measured boot, the process of hashing various components
+of the boot process, extending the results in the TPM and logging the
+component's measurement in memory for the operating system to consume.
+
+Requirements
+---------------------
+
+* A hardware TPM 2.0 supported by the U-Boot drivers

doc/usage/measured_boot.rst line 23

Quoted 10 lines
doc/usage/measured_boot.rst new file +10 -0
+* CONFIG_TPM=y
+* CONFIG_MEASURED_BOOT=y
+* Device-tree configuration of the TPM device to specify the memory area
+  for event logging. The TPM device node must either contain a phandle to
+  a reserved memory region or "linux,sml-base" and "linux,sml-size"
+  indicating the address and size of the memory region. An example can be
+  found in arch/sandbox/dts/test.dts
+* The operating system must also be configured to use the memory regions
+  specified in the U-Boot device-tree in order to make use of the event
+  log.

Please, provide enough information such that a reader can set this up. This should include example code.

Best regards

Heinrich

#18 lore raw

Re: [PATCH v6 6/6] doc: Add measured boot documentation

In reply to Heinrich Schuchardt
Quoted 49 lines · Heinrich Schuchardt

Am 22. Februar 2023 19:02:42 MEZ schrieb Eddie James <[email protected]>:

Quoted 27 lines

Briefly describe the feature and specify the requirements.

---
doc/usage/index.rst | 1 +
doc/usage/measured_boot.rst | 23 +++++++++++++++++++++++

2 files changed, 24 insertions(+)

create mode 100644 doc/usage/measured_boot.rst

doc/usage/index.rst +1 -0
index cde7dcb14a..0cf78cb0e7 100644
@@ -12,6 +12,7 @@ Use U-Boot
    partitions
    cmdline
    semihosting
+   measured_boot
 

Shell commands
--------------

doc/usage/measured_boot.rst new file +0 -0
new file mode 100644
index 0000000000..8357b1f480

doc/usage/measured_boot.rst line 4

Quoted 4 lines
doc/usage/measured_boot.rst new file +4 -0
@@ -0,0 +1,23 @@
+.. SPDX-License-Identifier: GPL-2.0+
+
+Measured Boot
+=====================

This completely misses o describe measured boot with UEFI.

@Ilias, do you want to add that in a follow up patch?

Quoted 12 lines
doc/usage/measured_boot.rst new file +12 -0
+
+U-Boot can perform a measured boot, the process of hashing various components
+of the boot process, extending the results in the TPM and logging the
+component's measurement in memory for the operating system to consume.
+
+Requirements
+---------------------
+
+* A hardware TPM 2.0 supported by the U-Boot drivers
+* CONFIG_TPM=y
+* CONFIG_MEASURED_BOOT=y
+* Device-tree configuration of the TPM device to specify the memory area
Quoted 8 lines

doc/usage/measured_boot.rst line 23

Quoted 7 lines
doc/usage/measured_boot.rst new file +7 -0
+  for event logging. The TPM device node must either contain a phandle to
+  a reserved memory region or "linux,sml-base" and "linux,sml-size"
+  indicating the address and size of the memory region. An example can be
+  found in arch/sandbox/dts/test.dts
+* The operating system must also be configured to use the memory regions
+  specified in the U-Boot device-tree in order to make use of the event
+  log.

Please, provide enough information such that a reader can set this up. This should include example code.

Hi Heinrich,

I'm not sure what example code you mean. No additional code is necessary for U-Boot to perform the measurements, only the requirements stated. If you mean the operating system setup, I don't think here is the right place to document that, as it has nothing to do with U-Boot. Either way, Linux would not require any code, only a similar devicetree entry and TPM driver.

Thanks,

Eddie

Quoted 4 lines

Best regards

Heinrich