/* * Copyright (c) 2020, Arm Limited. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ #include #include #include #include #include #include #include #include #include #include /* Event Log data */ static uint8_t event_log[EVENT_LOG_SIZE]; /* End of Event Log */ #define EVENT_LOG_END ((uintptr_t)event_log + sizeof(event_log) - 1U) CASSERT(sizeof(event_log) >= LOG_MIN_SIZE, assert_event_log_size); /* Pointer in event_log[] */ static uint8_t *log_ptr = event_log; /* Pointer to measured_boot_data_t */ const static measured_boot_data_t *plat_data_ptr; static uintptr_t tos_fw_config_base; static uintptr_t nt_fw_config_base; /* 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 } }; /* Platform's table with platform specific image IDs, names and PCRs */ static const image_data_t plat_images_data[] = { { BL2_IMAGE_ID, BL2_STRING, PCR_0 }, /* Reserved for BL2 */ { INVALID_ID, NULL, (unsigned int)(-1) } /* Terminator */ }; static const measured_boot_data_t plat_measured_boot_data = { plat_images_data, NULL, /* platform_set_nt_fw_info */ NULL /* platform_set_tos_fw_info */ }; /* * Function retuns pointer to platform's measured_boot_data_t structure * * Must be overridden in the platform code */ #pragma weak plat_get_measured_boot_data const measured_boot_data_t *plat_get_measured_boot_data(void) { return &plat_measured_boot_data; } /* * Add TCG_PCR_EVENT2 event * * @param[in] hash Pointer to hash data of TCG_DIGEST_SIZE bytes * @param[in] image_ptr Pointer to image_data_t structure * @return: * 0 = success * < 0 = error code */ static int add_event2(const uint8_t *hash, const image_data_t *image_ptr) { void *ptr = log_ptr; uint32_t name_len; uint32_t size_of_event; assert(image_ptr != NULL); assert(image_ptr->name != NULL); name_len = (uint32_t)strlen(image_ptr->name) + 1U; size_of_event = name_len + (uint32_t)EVENT2_HDR_SIZE; /* Check for space in Event Log buffer */ if (((uintptr_t)ptr + size_of_event) > EVENT_LOG_END) { ERROR("%s(): Event Log is short of memory", __func__); return -ENOMEM; } /* * 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 = image_ptr->pcr; /* TCG_PCR_EVENT2.EventType */ ((event2_header_t *)ptr)->event_type = EV_POST_CODE; /* 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 *)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 *)ptr + offsetof(tpmt_ha, digest); /* Check for space in Event Log buffer */ if (((uintptr_t)ptr + TCG_DIGEST_SIZE) > EVENT_LOG_END) { ERROR("%s(): Event Log is short of memory", __func__); return -ENOMEM; } if (hash == NULL) { /* Get BL2 hash from DTB */ bl2_plat_get_hash(ptr); } else { /* Copy digest */ (void)memcpy(ptr, (const void *)hash, TCG_DIGEST_SIZE); } /* TCG_PCR_EVENT2.EventSize */ ptr = (uint8_t *)ptr + TCG_DIGEST_SIZE; ((event2_data_t *)ptr)->event_size = name_len; /* Copy event data to TCG_PCR_EVENT2.Event */ (void)memcpy((void *)(((event2_data_t *)ptr)->event), (const void *)image_ptr->name, name_len); /* End of event data */ log_ptr = (uint8_t *)ptr + offsetof(event2_data_t, event) + name_len; return 0; } /* * Init Event Log * * Initialises Event Log by writing Specification ID and * Startup Locality events. */ void event_log_init(void) { const char locality_signature[] = TCG_STARTUP_LOCALITY_SIGNATURE; const uint8_t *start_ptr; void *ptr = event_log; /* Get pointer to platform's measured_boot_data_t structure */ plat_data_ptr = plat_get_measured_boot_data(); /* * 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 *)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 *)ptr + sizeof(id_event_algorithm_size_t); /* * TCG_EfiSpecIDEventStruct.vendorInfoSize * No vendor data */ ((id_event_struct_data_t *)ptr)->vendor_info_size = 0; ptr = (uint8_t *)ptr + offsetof(id_event_struct_data_t, vendor_info); if ((uintptr_t)ptr != ((uintptr_t)event_log + ID_EVENT_SIZE)) { panic(); } start_ptr = (uint8_t *)ptr; /* * 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 *)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, TPM_ALG_ID); ptr = (uint8_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 *)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; ptr = (uint8_t *)ptr + sizeof(startup_locality_event_t); if ((uintptr_t)ptr != ((uintptr_t)start_ptr + LOC_EVENT_SIZE)) { panic(); } log_ptr = (uint8_t *)ptr; /* Add BL2 event */ if (add_event2(NULL, plat_data_ptr->images_data) != 0) { panic(); } } /* * 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 tpm_record_measurement(uintptr_t data_base, uint32_t data_size, uint32_t data_id) { const image_data_t *data_ptr = plat_data_ptr->images_data; unsigned char hash_data[MBEDTLS_MD_MAX_SIZE]; int rc; /* Check if image_id is supported */ while (data_ptr->id != data_id) { if ((data_ptr++)->id == INVALID_ID) { ERROR("%s(): image_id %u not supported\n", __func__, data_id); return -EINVAL; } } if (data_id == TOS_FW_CONFIG_ID) { tos_fw_config_base = data_base; } else if (data_id == NT_FW_CONFIG_ID) { nt_fw_config_base = data_base; } else { /* No action */ } /* Calculate hash */ rc = crypto_mod_calc_hash((unsigned int)MBEDTLS_MD_ID, (void *)data_base, data_size, hash_data); if (rc != 0) { return rc; } return add_event2(hash_data, data_ptr); } /* * Finalise Event Log * * @param[out] log_addr Pointer to return Event Log address * @param[out] log_size Pointer to return Event Log size * @return: * 0 = success * < 0 = error code */ int event_log_finalise(uint8_t **log_addr, size_t *log_size) { /* Event Log size */ size_t num_bytes = (uintptr_t)log_ptr - (uintptr_t)event_log; int rc; assert(log_addr != NULL); assert(log_size != NULL); if (nt_fw_config_base == 0UL) { ERROR("%s(): %s_FW_CONFIG not loaded\n", __func__, "NT"); return -ENOENT; } /* * Set Event Log data in NT_FW_CONFIG and * get Event Log address in Non-Secure memory */ if (plat_data_ptr->set_nt_fw_info != NULL) { /* Event Log address in Non-Secure memory */ uintptr_t ns_log_addr; rc = plat_data_ptr->set_nt_fw_info( nt_fw_config_base, #ifdef SPD_opteed (uintptr_t)event_log, #endif num_bytes, &ns_log_addr); if (rc != 0) { ERROR("%s(): Unable to update %s_FW_CONFIG\n", __func__, "NT"); return rc; } /* Copy Event Log to Non-secure memory */ (void)memcpy((void *)ns_log_addr, (const void *)event_log, num_bytes); /* Ensure that the Event Log is visible in Non-secure memory */ flush_dcache_range(ns_log_addr, num_bytes); /* Return Event Log address in Non-Secure memory */ *log_addr = (uint8_t *)ns_log_addr; } else { INFO("%s(): set_%s_fw_info not set\n", __func__, "nt"); /* Return Event Log address in Secure memory */ *log_addr = event_log; } if (tos_fw_config_base != 0UL) { if (plat_data_ptr->set_tos_fw_info != NULL) { /* Set Event Log data in TOS_FW_CONFIG */ rc = plat_data_ptr->set_tos_fw_info( tos_fw_config_base, (uintptr_t)event_log, num_bytes); if (rc != 0) { ERROR("%s(): Unable to update %s_FW_CONFIG\n", __func__, "TOS"); return rc; } } else { INFO("%s(): set_%s_fw_info not set\n", __func__, "tos"); } } else { INFO("%s(): %s_FW_CONFIG not loaded\n", __func__, "TOS"); } /* Ensure that the Event Log is visible in Secure memory */ flush_dcache_range((uintptr_t)event_log, num_bytes); /* Return Event Log size */ *log_size = num_bytes; return 0; }