1 /* 2 * Copyright (c) 2020-2022, Arm Limited. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 #include <errno.h> 9 #include <string.h> 10 #include <arch_helpers.h> 11 12 #include <common/bl_common.h> 13 #include <common/debug.h> 14 #include <drivers/auth/crypto_mod.h> 15 #include <drivers/measured_boot/event_log/event_log.h> 16 17 #if TPM_ALG_ID == TPM_ALG_SHA512 18 #define CRYPTO_MD_ID CRYPTO_MD_SHA512 19 #elif TPM_ALG_ID == TPM_ALG_SHA384 20 #define CRYPTO_MD_ID CRYPTO_MD_SHA384 21 #elif TPM_ALG_ID == TPM_ALG_SHA256 22 #define CRYPTO_MD_ID CRYPTO_MD_SHA256 23 #else 24 # error Invalid TPM algorithm. 25 #endif /* TPM_ALG_ID */ 26 27 /* Running Event Log Pointer */ 28 static uint8_t *log_ptr; 29 30 /* Pointer to the first byte past end of the Event Log buffer */ 31 static uintptr_t log_end; 32 33 /* TCG_EfiSpecIdEvent */ 34 static const id_event_headers_t id_event_header = { 35 .header = { 36 .pcr_index = PCR_0, 37 .event_type = EV_NO_ACTION, 38 .digest = {0}, 39 .event_size = (uint32_t)(sizeof(id_event_struct_t) + 40 (sizeof(id_event_algorithm_size_t) * 41 HASH_ALG_COUNT)) 42 }, 43 44 .struct_header = { 45 .signature = TCG_ID_EVENT_SIGNATURE_03, 46 .platform_class = PLATFORM_CLASS_CLIENT, 47 .spec_version_minor = TCG_SPEC_VERSION_MINOR_TPM2, 48 .spec_version_major = TCG_SPEC_VERSION_MAJOR_TPM2, 49 .spec_errata = TCG_SPEC_ERRATA_TPM2, 50 .uintn_size = (uint8_t)(sizeof(unsigned int) / 51 sizeof(uint32_t)), 52 .number_of_algorithms = HASH_ALG_COUNT 53 } 54 }; 55 56 static const event2_header_t locality_event_header = { 57 /* 58 * All EV_NO_ACTION events SHALL set 59 * TCG_PCR_EVENT2.pcrIndex = 0, unless otherwise specified 60 */ 61 .pcr_index = PCR_0, 62 63 /* 64 * All EV_NO_ACTION events SHALL set 65 * TCG_PCR_EVENT2.eventType = 03h 66 */ 67 .event_type = EV_NO_ACTION, 68 69 /* 70 * All EV_NO_ACTION events SHALL set TCG_PCR_EVENT2.digests to all 71 * 0x00's for each allocated Hash algorithm 72 */ 73 .digests = { 74 .count = HASH_ALG_COUNT 75 } 76 }; 77 78 /* 79 * Record a measurement as a TCG_PCR_EVENT2 event 80 * 81 * @param[in] hash Pointer to hash data of TCG_DIGEST_SIZE bytes 82 * @param[in] event_type Type of Event, Various Event Types are 83 * mentioned in tcg.h header 84 * @param[in] metadata_ptr Pointer to event_log_metadata_t structure 85 * 86 * There must be room for storing this new event into the event log buffer. 87 */ 88 void event_log_record(const uint8_t *hash, uint32_t event_type, 89 const event_log_metadata_t *metadata_ptr) 90 { 91 void *ptr = log_ptr; 92 uint32_t name_len = 0U; 93 94 assert(hash != NULL); 95 assert(metadata_ptr != NULL); 96 /* event_log_buf_init() must have been called prior to this. */ 97 assert(log_ptr != NULL); 98 99 if (metadata_ptr->name != NULL) { 100 name_len = (uint32_t)strlen(metadata_ptr->name) + 1U; 101 } 102 103 /* Check for space in Event Log buffer */ 104 assert(((uintptr_t)ptr + (uint32_t)EVENT2_HDR_SIZE + name_len) < 105 log_end); 106 107 /* 108 * As per TCG specifications, firmware components that are measured 109 * into PCR[0] must be logged in the event log using the event type 110 * EV_POST_CODE. 111 */ 112 /* TCG_PCR_EVENT2.PCRIndex */ 113 ((event2_header_t *)ptr)->pcr_index = metadata_ptr->pcr; 114 115 /* TCG_PCR_EVENT2.EventType */ 116 ((event2_header_t *)ptr)->event_type = event_type; 117 118 /* TCG_PCR_EVENT2.Digests.Count */ 119 ptr = (uint8_t *)ptr + offsetof(event2_header_t, digests); 120 ((tpml_digest_values *)ptr)->count = HASH_ALG_COUNT; 121 122 /* TCG_PCR_EVENT2.Digests[] */ 123 ptr = (uint8_t *)((uintptr_t)ptr + 124 offsetof(tpml_digest_values, digests)); 125 126 /* TCG_PCR_EVENT2.Digests[].AlgorithmId */ 127 ((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID; 128 129 /* TCG_PCR_EVENT2.Digests[].Digest[] */ 130 ptr = (uint8_t *)((uintptr_t)ptr + offsetof(tpmt_ha, digest)); 131 132 /* Copy digest */ 133 (void)memcpy(ptr, (const void *)hash, TCG_DIGEST_SIZE); 134 135 /* TCG_PCR_EVENT2.EventSize */ 136 ptr = (uint8_t *)((uintptr_t)ptr + TCG_DIGEST_SIZE); 137 ((event2_data_t *)ptr)->event_size = name_len; 138 139 /* Copy event data to TCG_PCR_EVENT2.Event */ 140 if (metadata_ptr->name != NULL) { 141 (void)memcpy((void *)(((event2_data_t *)ptr)->event), 142 (const void *)metadata_ptr->name, name_len); 143 } 144 145 /* End of event data */ 146 log_ptr = (uint8_t *)((uintptr_t)ptr + 147 offsetof(event2_data_t, event) + name_len); 148 } 149 150 void event_log_buf_init(uint8_t *event_log_start, uint8_t *event_log_finish) 151 { 152 assert(event_log_start != NULL); 153 assert(event_log_finish > event_log_start); 154 155 log_ptr = event_log_start; 156 log_end = (uintptr_t)event_log_finish; 157 } 158 159 /* 160 * Initialise Event Log global variables, used during the recording 161 * of various payload measurements into the Event Log buffer 162 * 163 * @param[in] event_log_start Base address of Event Log buffer 164 * @param[in] event_log_finish End address of Event Log buffer, 165 * it is a first byte past end of the 166 * buffer 167 */ 168 void event_log_init(uint8_t *event_log_start, uint8_t *event_log_finish) 169 { 170 event_log_buf_init(event_log_start, event_log_finish); 171 } 172 173 void event_log_write_specid_event(void) 174 { 175 void *ptr = log_ptr; 176 177 /* event_log_buf_init() must have been called prior to this. */ 178 assert(log_ptr != NULL); 179 assert(((uintptr_t)log_ptr + ID_EVENT_SIZE) < log_end); 180 181 /* 182 * Add Specification ID Event first 183 * 184 * Copy TCG_EfiSpecIDEventStruct structure header 185 */ 186 (void)memcpy(ptr, (const void *)&id_event_header, 187 sizeof(id_event_header)); 188 ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_header)); 189 190 /* TCG_EfiSpecIdEventAlgorithmSize structure */ 191 ((id_event_algorithm_size_t *)ptr)->algorithm_id = TPM_ALG_ID; 192 ((id_event_algorithm_size_t *)ptr)->digest_size = TCG_DIGEST_SIZE; 193 ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_algorithm_size_t)); 194 195 /* 196 * TCG_EfiSpecIDEventStruct.vendorInfoSize 197 * No vendor data 198 */ 199 ((id_event_struct_data_t *)ptr)->vendor_info_size = 0; 200 log_ptr = (uint8_t *)((uintptr_t)ptr + 201 offsetof(id_event_struct_data_t, vendor_info)); 202 } 203 204 /* 205 * Initialises Event Log by writing Specification ID and 206 * Startup Locality events 207 */ 208 void event_log_write_header(void) 209 { 210 const char locality_signature[] = TCG_STARTUP_LOCALITY_SIGNATURE; 211 void *ptr; 212 213 event_log_write_specid_event(); 214 215 ptr = log_ptr; 216 assert(((uintptr_t)log_ptr + LOC_EVENT_SIZE) < log_end); 217 218 /* 219 * The Startup Locality event should be placed in the log before 220 * any event which extends PCR[0]. 221 * 222 * Ref. TCG PC Client Platform Firmware Profile 9.4.5.3 223 */ 224 225 /* Copy Startup Locality Event Header */ 226 (void)memcpy(ptr, (const void *)&locality_event_header, 227 sizeof(locality_event_header)); 228 ptr = (uint8_t *)((uintptr_t)ptr + sizeof(locality_event_header)); 229 230 /* TCG_PCR_EVENT2.Digests[].AlgorithmId */ 231 ((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID; 232 233 /* TCG_PCR_EVENT2.Digests[].Digest[] */ 234 (void)memset(&((tpmt_ha *)ptr)->digest, 0, TCG_DIGEST_SIZE); 235 ptr = (uint8_t *)((uintptr_t)ptr + 236 offsetof(tpmt_ha, digest) + TCG_DIGEST_SIZE); 237 238 /* TCG_PCR_EVENT2.EventSize */ 239 ((event2_data_t *)ptr)->event_size = 240 (uint32_t)sizeof(startup_locality_event_t); 241 ptr = (uint8_t *)((uintptr_t)ptr + offsetof(event2_data_t, event)); 242 243 /* TCG_EfiStartupLocalityEvent.Signature */ 244 (void)memcpy(ptr, (const void *)locality_signature, 245 sizeof(TCG_STARTUP_LOCALITY_SIGNATURE)); 246 247 /* 248 * TCG_EfiStartupLocalityEvent.StartupLocality = 0: 249 * the platform's boot firmware 250 */ 251 ((startup_locality_event_t *)ptr)->startup_locality = 0U; 252 log_ptr = (uint8_t *)((uintptr_t)ptr + sizeof(startup_locality_event_t)); 253 } 254 255 int event_log_measure(uintptr_t data_base, uint32_t data_size, 256 unsigned char hash_data[CRYPTO_MD_MAX_SIZE]) 257 { 258 /* Calculate hash */ 259 return crypto_mod_calc_hash(CRYPTO_MD_ID, 260 (void *)data_base, data_size, hash_data); 261 } 262 263 /* 264 * Calculate and write hash of image, configuration data, etc. 265 * to Event Log. 266 * 267 * @param[in] data_base Address of data 268 * @param[in] data_size Size of data 269 * @param[in] data_id Data ID 270 * @param[in] metadata_ptr Event Log metadata 271 * @return: 272 * 0 = success 273 * < 0 = error 274 */ 275 int event_log_measure_and_record(uintptr_t data_base, uint32_t data_size, 276 uint32_t data_id, 277 const event_log_metadata_t *metadata_ptr) 278 { 279 unsigned char hash_data[CRYPTO_MD_MAX_SIZE]; 280 int rc; 281 282 assert(metadata_ptr != NULL); 283 284 /* Get the metadata associated with this image. */ 285 while ((metadata_ptr->id != EVLOG_INVALID_ID) && 286 (metadata_ptr->id != data_id)) { 287 metadata_ptr++; 288 } 289 assert(metadata_ptr->id != EVLOG_INVALID_ID); 290 291 /* Measure the payload with algorithm selected by EventLog driver */ 292 rc = event_log_measure(data_base, data_size, hash_data); 293 if (rc != 0) { 294 return rc; 295 } 296 297 event_log_record(hash_data, EV_POST_CODE, metadata_ptr); 298 299 return 0; 300 } 301 302 /* 303 * Get current Event Log buffer size i.e. used space of Event Log buffer 304 * 305 * @param[in] event_log_start Base Pointer to Event Log buffer 306 * 307 * @return: current Size of Event Log buffer 308 */ 309 size_t event_log_get_cur_size(uint8_t *event_log_start) 310 { 311 assert(event_log_start != NULL); 312 assert(log_ptr >= event_log_start); 313 314 return (size_t)((uintptr_t)log_ptr - (uintptr_t)event_log_start); 315 } 316