drivers/measured_boot/event_log/event_log.c - filogic/atf - Gitiles

 /*
  * Copyright (c) 2020-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */

 #include <assert.h>
 #include <errno.h>
 #include <string.h>
 #include <arch_helpers.h>

 #include <common/bl_common.h>
 #include <common/debug.h>
 #include <drivers/auth/crypto_mod.h>
 #include <drivers/measured_boot/event_log/event_log.h>

 #include <plat/common/platform.h>

 #if TPM_ALG_ID == TPM_ALG_SHA512
 #define	CRYPTO_MD_ID	CRYPTO_MD_SHA512
 #elif TPM_ALG_ID == TPM_ALG_SHA384
 #define	CRYPTO_MD_ID	CRYPTO_MD_SHA384
 #elif TPM_ALG_ID == TPM_ALG_SHA256
 #define	CRYPTO_MD_ID	CRYPTO_MD_SHA256
 #else
 #  error Invalid TPM algorithm.
 #endif /* TPM_ALG_ID */

 /* Running Event Log Pointer */
 static uint8_t *log_ptr;

 /* Pointer to the first byte past end of the Event Log buffer */
 static uintptr_t log_end;

 /* Pointer to event_log_metadata_t */
 static const event_log_metadata_t *plat_metadata_ptr;

 /* TCG_EfiSpecIdEvent */
 static const id_event_headers_t id_event_header = {
 	.header = {
 		.pcr_index = PCR_0,
 		.event_type = EV_NO_ACTION,
 		.digest = {0},
 		.event_size = (uint32_t)(sizeof(id_event_struct_t) +
 				(sizeof(id_event_algorithm_size_t) *
 				HASH_ALG_COUNT))
 	},

 	.struct_header = {
 		.signature = TCG_ID_EVENT_SIGNATURE_03,
 		.platform_class = PLATFORM_CLASS_CLIENT,
 		.spec_version_minor = TCG_SPEC_VERSION_MINOR_TPM2,
 		.spec_version_major = TCG_SPEC_VERSION_MAJOR_TPM2,
 		.spec_errata = TCG_SPEC_ERRATA_TPM2,
 		.uintn_size = (uint8_t)(sizeof(unsigned int) /
 					sizeof(uint32_t)),
 		.number_of_algorithms = HASH_ALG_COUNT
 	}
 };

 static const event2_header_t locality_event_header = {
 	/*
 	 * All EV_NO_ACTION events SHALL set
 	 * TCG_PCR_EVENT2.pcrIndex = 0, unless otherwise specified
 	 */
 	.pcr_index = PCR_0,

 	/*
 	 * All EV_NO_ACTION events SHALL set
 	 * TCG_PCR_EVENT2.eventType = 03h
 	 */
 	.event_type = EV_NO_ACTION,

 	/*
 	 * All EV_NO_ACTION events SHALL set TCG_PCR_EVENT2.digests to all
 	 * 0x00's for each allocated Hash algorithm
 	 */
 	.digests = {
 		.count = HASH_ALG_COUNT
 	}
 };

 /*
  * Record a measurement as a TCG_PCR_EVENT2 event
  *
  * @param[in] hash		Pointer to hash data of TCG_DIGEST_SIZE bytes
  * @param[in] event_type	Type of Event, Various Event Types are
  * 				mentioned in tcg.h header
  * @param[in] metadata_ptr	Pointer to event_log_metadata_t structure
  *
  * There must be room for storing this new event into the event log buffer.
  */
 void event_log_record(const uint8_t *hash, uint32_t event_type,
 		      const event_log_metadata_t *metadata_ptr)
 {
 	void *ptr = log_ptr;
 	uint32_t name_len = 0U;

 	assert(hash != NULL);
 	assert(metadata_ptr != NULL);
 	/* event_log_buf_init() must have been called prior to this. */
 	assert(log_ptr != NULL);

 	if (metadata_ptr->name != NULL) {
 		name_len = (uint32_t)strlen(metadata_ptr->name) + 1U;
 	}

 	/* Check for space in Event Log buffer */
 	assert(((uintptr_t)ptr + (uint32_t)EVENT2_HDR_SIZE + name_len) <
 	       log_end);

 	/*
 	 * As per TCG specifications, firmware components that are measured
 	 * into PCR[0] must be logged in the event log using the event type
 	 * EV_POST_CODE.
 	 */
 	/* TCG_PCR_EVENT2.PCRIndex */
 	((event2_header_t *)ptr)->pcr_index = metadata_ptr->pcr;

 	/* TCG_PCR_EVENT2.EventType */
 	((event2_header_t *)ptr)->event_type = event_type;

 	/* TCG_PCR_EVENT2.Digests.Count */
 	ptr = (uint8_t *)ptr + offsetof(event2_header_t, digests);
 	((tpml_digest_values *)ptr)->count = HASH_ALG_COUNT;

 	/* TCG_PCR_EVENT2.Digests[] */
 	ptr = (uint8_t *)((uintptr_t)ptr +
 			offsetof(tpml_digest_values, digests));

 	/* TCG_PCR_EVENT2.Digests[].AlgorithmId */
 	((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID;

 	/* TCG_PCR_EVENT2.Digests[].Digest[] */
 	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(tpmt_ha, digest));

 	/* Copy digest */
 	(void)memcpy(ptr, (const void *)hash, TCG_DIGEST_SIZE);

 	/* TCG_PCR_EVENT2.EventSize */
 	ptr = (uint8_t *)((uintptr_t)ptr + TCG_DIGEST_SIZE);
 	((event2_data_t *)ptr)->event_size = name_len;

 	/* Copy event data to TCG_PCR_EVENT2.Event */
 	if (metadata_ptr->name != NULL) {
 		(void)memcpy((void *)(((event2_data_t *)ptr)->event),
 				(const void *)metadata_ptr->name, name_len);
 	}

 	/* End of event data */
 	log_ptr = (uint8_t *)((uintptr_t)ptr +
 			offsetof(event2_data_t, event) + name_len);
 }

 void event_log_buf_init(uint8_t *event_log_start, uint8_t *event_log_finish)
 {
 	assert(event_log_start != NULL);
 	assert(event_log_finish > event_log_start);

 	log_ptr = event_log_start;
 	log_end = (uintptr_t)event_log_finish;
 }

 /*
  * Initialise Event Log global variables, used during the recording
  * of various payload measurements into the Event Log buffer
  *
  * @param[in] event_log_start		Base address of Event Log buffer
  * @param[in] event_log_finish		End address of Event Log buffer,
  * 					it is a first byte past end of the
  * 					buffer
  */
 void event_log_init(uint8_t *event_log_start, uint8_t *event_log_finish)
 {
 	event_log_buf_init(event_log_start, event_log_finish);

 	/* Get pointer to platform's event_log_metadata_t structure */
 	plat_metadata_ptr = plat_event_log_get_metadata();
 	assert(plat_metadata_ptr != NULL);
 }

 void event_log_write_specid_event(void)
 {
 	void *ptr = log_ptr;

 	/* event_log_buf_init() must have been called prior to this. */
 	assert(log_ptr != NULL);
 	assert(((uintptr_t)log_ptr + ID_EVENT_SIZE) < log_end);

 	/*
 	 * Add Specification ID Event first
 	 *
 	 * Copy TCG_EfiSpecIDEventStruct structure header
 	 */
 	(void)memcpy(ptr, (const void *)&id_event_header,
 			sizeof(id_event_header));
 	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_header));

 	/* TCG_EfiSpecIdEventAlgorithmSize structure */
 	((id_event_algorithm_size_t *)ptr)->algorithm_id = TPM_ALG_ID;
 	((id_event_algorithm_size_t *)ptr)->digest_size = TCG_DIGEST_SIZE;
 	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_algorithm_size_t));

 	/*
 	 * TCG_EfiSpecIDEventStruct.vendorInfoSize
 	 * No vendor data
 	 */
 	((id_event_struct_data_t *)ptr)->vendor_info_size = 0;
 	log_ptr = (uint8_t *)((uintptr_t)ptr +
 			offsetof(id_event_struct_data_t, vendor_info));
 }

 /*
  * Initialises Event Log by writing Specification ID and
  * Startup Locality events
  */
 void event_log_write_header(void)
 {
 	const char locality_signature[] = TCG_STARTUP_LOCALITY_SIGNATURE;
 	void *ptr;

 	event_log_write_specid_event();

 	ptr = log_ptr;
 	assert(((uintptr_t)log_ptr + LOC_EVENT_SIZE) < log_end);

 	/*
 	 * The Startup Locality event should be placed in the log before
 	 * any event which extends PCR[0].
 	 *
 	 * Ref. TCG PC Client Platform Firmware Profile 9.4.5.3
 	 */

 	/* Copy Startup Locality Event Header */
 	(void)memcpy(ptr, (const void *)&locality_event_header,
 			sizeof(locality_event_header));
 	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(locality_event_header));

 	/* TCG_PCR_EVENT2.Digests[].AlgorithmId */
 	((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID;

 	/* TCG_PCR_EVENT2.Digests[].Digest[] */
 	(void)memset(&((tpmt_ha *)ptr)->digest, 0, TCG_DIGEST_SIZE);
 	ptr = (uint8_t *)((uintptr_t)ptr +
 			offsetof(tpmt_ha, digest) + TCG_DIGEST_SIZE);

 	/* TCG_PCR_EVENT2.EventSize */
 	((event2_data_t *)ptr)->event_size =
 		(uint32_t)sizeof(startup_locality_event_t);
 	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(event2_data_t, event));

 	/* TCG_EfiStartupLocalityEvent.Signature */
 	(void)memcpy(ptr, (const void *)locality_signature,
 		sizeof(TCG_STARTUP_LOCALITY_SIGNATURE));

 	/*
 	 * TCG_EfiStartupLocalityEvent.StartupLocality = 0:
 	 * the platform's boot firmware
 	 */
 	((startup_locality_event_t *)ptr)->startup_locality = 0U;
 	log_ptr = (uint8_t *)((uintptr_t)ptr + sizeof(startup_locality_event_t));
 }

 int event_log_measure(uintptr_t data_base, uint32_t data_size,
 		      unsigned char hash_data[CRYPTO_MD_MAX_SIZE])
 {
 	/* Calculate hash */
 	return crypto_mod_calc_hash(CRYPTO_MD_ID,
 				    (void *)data_base, data_size, hash_data);
 }

 /*
  * Calculate and write hash of image, configuration data, etc.
  * to Event Log.
  *
  * @param[in] data_base		Address of data
  * @param[in] data_size		Size of data
  * @param[in] data_id		Data ID
  * @return:
  *	0 = success
  *    < 0 = error
  */
 int event_log_measure_and_record(uintptr_t data_base, uint32_t data_size,
 				 uint32_t data_id)
 {
 	unsigned char hash_data[CRYPTO_MD_MAX_SIZE];
 	int rc;
 	const event_log_metadata_t *metadata_ptr = plat_metadata_ptr;

 	/* Get the metadata associated with this image. */
 	while ((metadata_ptr->id != EVLOG_INVALID_ID) &&
 		(metadata_ptr->id != data_id)) {
 		metadata_ptr++;
 	}
 	assert(metadata_ptr->id != EVLOG_INVALID_ID);

 	/* Measure the payload with algorithm selected by EventLog driver */
 	rc = event_log_measure(data_base, data_size, hash_data);
 	if (rc != 0) {
 		return rc;
 	}

 	event_log_record(hash_data, EV_POST_CODE, metadata_ptr);

 	return 0;
 }

 /*
  * Get current Event Log buffer size i.e. used space of Event Log buffer
  *
  * @param[in]  event_log_start		Base Pointer to Event Log buffer
  *
  * @return: current Size of Event Log buffer
  */
 size_t event_log_get_cur_size(uint8_t *event_log_start)
 {
 	assert(event_log_start != NULL);
 	assert(log_ptr >= event_log_start);

 	return (size_t)((uintptr_t)log_ptr - (uintptr_t)event_log_start);
 }
	/*
	* Copyright (c) 2020-2022, Arm Limited. All rights reserved.
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	#include <assert.h>
	#include <errno.h>
	#include <string.h>
	#include <arch_helpers.h>

	#include <common/bl_common.h>
	#include <common/debug.h>
	#include <drivers/auth/crypto_mod.h>
	#include <drivers/measured_boot/event_log/event_log.h>

	#include <plat/common/platform.h>

	#if TPM_ALG_ID == TPM_ALG_SHA512
	#define CRYPTO_MD_ID CRYPTO_MD_SHA512
	#elif TPM_ALG_ID == TPM_ALG_SHA384
	#define CRYPTO_MD_ID CRYPTO_MD_SHA384
	#elif TPM_ALG_ID == TPM_ALG_SHA256
	#define CRYPTO_MD_ID CRYPTO_MD_SHA256
	#else
	# error Invalid TPM algorithm.
	#endif /* TPM_ALG_ID */

	/* Running Event Log Pointer */
	static uint8_t *log_ptr;

	/* Pointer to the first byte past end of the Event Log buffer */
	static uintptr_t log_end;

	/* Pointer to event_log_metadata_t */
	static const event_log_metadata_t *plat_metadata_ptr;

	/* TCG_EfiSpecIdEvent */
	static const id_event_headers_t id_event_header = {
	.header = {
	.pcr_index = PCR_0,
	.event_type = EV_NO_ACTION,
	.digest = {0},
	.event_size = (uint32_t)(sizeof(id_event_struct_t) +
	(sizeof(id_event_algorithm_size_t) *
	HASH_ALG_COUNT))
	},

	.struct_header = {
	.signature = TCG_ID_EVENT_SIGNATURE_03,
	.platform_class = PLATFORM_CLASS_CLIENT,
	.spec_version_minor = TCG_SPEC_VERSION_MINOR_TPM2,
	.spec_version_major = TCG_SPEC_VERSION_MAJOR_TPM2,
	.spec_errata = TCG_SPEC_ERRATA_TPM2,
	.uintn_size = (uint8_t)(sizeof(unsigned int) /
	sizeof(uint32_t)),
	.number_of_algorithms = HASH_ALG_COUNT
	}
	};

	static const event2_header_t locality_event_header = {
	/*
	* All EV_NO_ACTION events SHALL set
	* TCG_PCR_EVENT2.pcrIndex = 0, unless otherwise specified
	*/
	.pcr_index = PCR_0,

	/*
	* All EV_NO_ACTION events SHALL set
	* TCG_PCR_EVENT2.eventType = 03h
	*/
	.event_type = EV_NO_ACTION,

	/*
	* All EV_NO_ACTION events SHALL set TCG_PCR_EVENT2.digests to all
	* 0x00's for each allocated Hash algorithm
	*/
	.digests = {
	.count = HASH_ALG_COUNT
	}
	};

	/*
	* Record a measurement as a TCG_PCR_EVENT2 event
	*
	* @param[in] hash Pointer to hash data of TCG_DIGEST_SIZE bytes
	* @param[in] event_type Type of Event, Various Event Types are
	* mentioned in tcg.h header
	* @param[in] metadata_ptr Pointer to event_log_metadata_t structure
	*
	* There must be room for storing this new event into the event log buffer.
	*/
	void event_log_record(const uint8_t *hash, uint32_t event_type,
	const event_log_metadata_t *metadata_ptr)
	{
	void *ptr = log_ptr;
	uint32_t name_len = 0U;

	assert(hash != NULL);
	assert(metadata_ptr != NULL);
	/* event_log_buf_init() must have been called prior to this. */
	assert(log_ptr != NULL);

	if (metadata_ptr->name != NULL) {
	name_len = (uint32_t)strlen(metadata_ptr->name) + 1U;
	}

	/* Check for space in Event Log buffer */
	assert(((uintptr_t)ptr + (uint32_t)EVENT2_HDR_SIZE + name_len) <
	log_end);

	/*
	* As per TCG specifications, firmware components that are measured
	* into PCR[0] must be logged in the event log using the event type
	* EV_POST_CODE.
	*/
	/* TCG_PCR_EVENT2.PCRIndex */
	((event2_header_t *)ptr)->pcr_index = metadata_ptr->pcr;

	/* TCG_PCR_EVENT2.EventType */
	((event2_header_t *)ptr)->event_type = event_type;

	/* TCG_PCR_EVENT2.Digests.Count */
	ptr = (uint8_t *)ptr + offsetof(event2_header_t, digests);
	((tpml_digest_values *)ptr)->count = HASH_ALG_COUNT;

	/* TCG_PCR_EVENT2.Digests[] */
	ptr = (uint8_t *)((uintptr_t)ptr +
	offsetof(tpml_digest_values, digests));

	/* TCG_PCR_EVENT2.Digests[].AlgorithmId */
	((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID;

	/* TCG_PCR_EVENT2.Digests[].Digest[] */
	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(tpmt_ha, digest));

	/* Copy digest */
	(void)memcpy(ptr, (const void *)hash, TCG_DIGEST_SIZE);

	/* TCG_PCR_EVENT2.EventSize */
	ptr = (uint8_t *)((uintptr_t)ptr + TCG_DIGEST_SIZE);
	((event2_data_t *)ptr)->event_size = name_len;

	/* Copy event data to TCG_PCR_EVENT2.Event */
	if (metadata_ptr->name != NULL) {
	(void)memcpy((void )(((event2_data_t )ptr)->event),
	(const void *)metadata_ptr->name, name_len);
	}

	/* End of event data */
	log_ptr = (uint8_t *)((uintptr_t)ptr +
	offsetof(event2_data_t, event) + name_len);
	}

	void event_log_buf_init(uint8_t event_log_start, uint8_t event_log_finish)
	{
	assert(event_log_start != NULL);
	assert(event_log_finish > event_log_start);

	log_ptr = event_log_start;
	log_end = (uintptr_t)event_log_finish;
	}

	/*
	* Initialise Event Log global variables, used during the recording
	* of various payload measurements into the Event Log buffer
	*
	* @param[in] event_log_start Base address of Event Log buffer
	* @param[in] event_log_finish End address of Event Log buffer,
	* it is a first byte past end of the
	* buffer
	*/
	void event_log_init(uint8_t event_log_start, uint8_t event_log_finish)
	{
	event_log_buf_init(event_log_start, event_log_finish);

	/* Get pointer to platform's event_log_metadata_t structure */
	plat_metadata_ptr = plat_event_log_get_metadata();
	assert(plat_metadata_ptr != NULL);
	}

	void event_log_write_specid_event(void)
	{
	void *ptr = log_ptr;

	/* event_log_buf_init() must have been called prior to this. */
	assert(log_ptr != NULL);
	assert(((uintptr_t)log_ptr + ID_EVENT_SIZE) < log_end);

	/*
	* Add Specification ID Event first
	*
	* Copy TCG_EfiSpecIDEventStruct structure header
	*/
	(void)memcpy(ptr, (const void *)&id_event_header,
	sizeof(id_event_header));
	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_header));

	/* TCG_EfiSpecIdEventAlgorithmSize structure */
	((id_event_algorithm_size_t *)ptr)->algorithm_id = TPM_ALG_ID;
	((id_event_algorithm_size_t *)ptr)->digest_size = TCG_DIGEST_SIZE;
	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_algorithm_size_t));

	/*
	* TCG_EfiSpecIDEventStruct.vendorInfoSize
	* No vendor data
	*/
	((id_event_struct_data_t *)ptr)->vendor_info_size = 0;
	log_ptr = (uint8_t *)((uintptr_t)ptr +
	offsetof(id_event_struct_data_t, vendor_info));
	}

	/*
	* Initialises Event Log by writing Specification ID and
	* Startup Locality events
	*/
	void event_log_write_header(void)
	{
	const char locality_signature[] = TCG_STARTUP_LOCALITY_SIGNATURE;
	void *ptr;

	event_log_write_specid_event();

	ptr = log_ptr;
	assert(((uintptr_t)log_ptr + LOC_EVENT_SIZE) < log_end);

	/*
	* The Startup Locality event should be placed in the log before
	* any event which extends PCR[0].
	*
	* Ref. TCG PC Client Platform Firmware Profile 9.4.5.3
	*/

	/* Copy Startup Locality Event Header */
	(void)memcpy(ptr, (const void *)&locality_event_header,
	sizeof(locality_event_header));
	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(locality_event_header));

	/* TCG_PCR_EVENT2.Digests[].AlgorithmId */
	((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID;

	/* TCG_PCR_EVENT2.Digests[].Digest[] */
	(void)memset(&((tpmt_ha *)ptr)->digest, 0, TCG_DIGEST_SIZE);
	ptr = (uint8_t *)((uintptr_t)ptr +
	offsetof(tpmt_ha, digest) + TCG_DIGEST_SIZE);

	/* TCG_PCR_EVENT2.EventSize */
	((event2_data_t *)ptr)->event_size =
	(uint32_t)sizeof(startup_locality_event_t);
	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(event2_data_t, event));

	/* TCG_EfiStartupLocalityEvent.Signature */
	(void)memcpy(ptr, (const void *)locality_signature,
	sizeof(TCG_STARTUP_LOCALITY_SIGNATURE));

	/*
	* TCG_EfiStartupLocalityEvent.StartupLocality = 0:
	* the platform's boot firmware
	*/
	((startup_locality_event_t *)ptr)->startup_locality = 0U;
	log_ptr = (uint8_t *)((uintptr_t)ptr + sizeof(startup_locality_event_t));
	}

	int event_log_measure(uintptr_t data_base, uint32_t data_size,
	unsigned char hash_data[CRYPTO_MD_MAX_SIZE])
	{
	/* Calculate hash */
	return crypto_mod_calc_hash(CRYPTO_MD_ID,
	(void *)data_base, data_size, hash_data);
	}

	/*
	* Calculate and write hash of image, configuration data, etc.
	* to Event Log.
	*
	* @param[in] data_base Address of data
	* @param[in] data_size Size of data
	* @param[in] data_id Data ID
	* @return:
	* 0 = success
	* < 0 = error
	*/
	int event_log_measure_and_record(uintptr_t data_base, uint32_t data_size,
	uint32_t data_id)
	{
	unsigned char hash_data[CRYPTO_MD_MAX_SIZE];
	int rc;
	const event_log_metadata_t *metadata_ptr = plat_metadata_ptr;

	/* Get the metadata associated with this image. */
	while ((metadata_ptr->id != EVLOG_INVALID_ID) &&
	(metadata_ptr->id != data_id)) {
	metadata_ptr++;
	}
	assert(metadata_ptr->id != EVLOG_INVALID_ID);

	/* Measure the payload with algorithm selected by EventLog driver */
	rc = event_log_measure(data_base, data_size, hash_data);
	if (rc != 0) {
	return rc;
	}

	event_log_record(hash_data, EV_POST_CODE, metadata_ptr);

	return 0;
	}

	/*
	* Get current Event Log buffer size i.e. used space of Event Log buffer
	*
	* @param[in] event_log_start Base Pointer to Event Log buffer
	*
	* @return: current Size of Event Log buffer
	*/
	size_t event_log_get_cur_size(uint8_t *event_log_start)
	{
	assert(event_log_start != NULL);
	assert(log_ptr >= event_log_start);

	return (size_t)((uintptr_t)log_ptr - (uintptr_t)event_log_start);
	}