1 /* SPDX-License-Identifier: GPL-2.0 */ 2 3 #ifndef __LINUX_TPM_EVENTLOG_H__ 4 #define __LINUX_TPM_EVENTLOG_H__ 5 6 #include <linux/tpm.h> 7 8 #define TCG_EVENT_NAME_LEN_MAX 255 9 #define MAX_TEXT_EVENT 1000 /* Max event string length */ 10 #define ACPI_TCPA_SIG "TCPA" /* 0x41504354 /'TCPA' */ 11 12 #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 0x1 13 #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2 0x2 14 15 #ifdef CONFIG_PPC64 16 #define do_endian_conversion(x) be32_to_cpu(x) 17 #else 18 #define do_endian_conversion(x) x 19 #endif 20 21 enum bios_platform_class { 22 BIOS_CLIENT = 0x00, 23 BIOS_SERVER = 0x01, 24 }; 25 26 struct tcpa_event { 27 u32 pcr_index; 28 u32 event_type; 29 u8 pcr_value[20]; /* SHA1 */ 30 u32 event_size; 31 u8 event_data[]; 32 }; 33 34 enum tcpa_event_types { 35 PREBOOT = 0, 36 POST_CODE, 37 UNUSED, 38 NO_ACTION, 39 SEPARATOR, 40 ACTION, 41 EVENT_TAG, 42 SCRTM_CONTENTS, 43 SCRTM_VERSION, 44 CPU_MICROCODE, 45 PLATFORM_CONFIG_FLAGS, 46 TABLE_OF_DEVICES, 47 COMPACT_HASH, 48 IPL, 49 IPL_PARTITION_DATA, 50 NONHOST_CODE, 51 NONHOST_CONFIG, 52 NONHOST_INFO, 53 }; 54 55 struct tcpa_pc_event { 56 u32 event_id; 57 u32 event_size; 58 u8 event_data[]; 59 }; 60 61 enum tcpa_pc_event_ids { 62 SMBIOS = 1, 63 BIS_CERT, 64 POST_BIOS_ROM, 65 ESCD, 66 CMOS, 67 NVRAM, 68 OPTION_ROM_EXEC, 69 OPTION_ROM_CONFIG, 70 OPTION_ROM_MICROCODE = 10, 71 S_CRTM_VERSION, 72 S_CRTM_CONTENTS, 73 POST_CONTENTS, 74 HOST_TABLE_OF_DEVICES, 75 }; 76 77 /* http://www.trustedcomputinggroup.org/tcg-efi-protocol-specification/ */ 78 79 struct tcg_efi_specid_event_algs { 80 u16 alg_id; 81 u16 digest_size; 82 } __packed; 83 84 #define TCG_SPECID_SIG "Spec ID Event03" 85 86 struct tcg_efi_specid_event_head { 87 u8 signature[16]; 88 u32 platform_class; 89 u8 spec_version_minor; 90 u8 spec_version_major; 91 u8 spec_errata; 92 u8 uintnsize; 93 u32 num_algs; 94 struct tcg_efi_specid_event_algs digest_sizes[]; 95 } __packed; 96 97 struct tcg_pcr_event { 98 u32 pcr_idx; 99 u32 event_type; 100 u8 digest[20]; 101 u32 event_size; 102 u8 event[]; 103 } __packed; 104 105 struct tcg_event_field { 106 u32 event_size; 107 u8 event[]; 108 } __packed; 109 110 struct tcg_pcr_event2_head { 111 u32 pcr_idx; 112 u32 event_type; 113 u32 count; 114 struct tpm_digest digests[]; 115 } __packed; 116 117 struct tcg_algorithm_size { 118 u16 algorithm_id; 119 u16 algorithm_size; 120 }; 121 122 struct tcg_algorithm_info { 123 u8 signature[16]; 124 u32 platform_class; 125 u8 spec_version_minor; 126 u8 spec_version_major; 127 u8 spec_errata; 128 u8 uintn_size; 129 u32 number_of_algorithms; 130 struct tcg_algorithm_size digest_sizes[]; 131 }; 132 133 #ifndef TPM_MEMREMAP 134 #define TPM_MEMREMAP(start, size) NULL 135 #endif 136 137 #ifndef TPM_MEMUNMAP 138 #define TPM_MEMUNMAP(start, size) do{} while(0) 139 #endif 140 141 /** 142 * __calc_tpm2_event_size - calculate the size of a TPM2 event log entry 143 * @event: Pointer to the event whose size should be calculated 144 * @event_header: Pointer to the initial event containing the digest lengths 145 * @do_mapping: Whether or not the event needs to be mapped 146 * 147 * The TPM2 event log format can contain multiple digests corresponding to 148 * separate PCR banks, and also contains a variable length of the data that 149 * was measured. This requires knowledge of how long each digest type is, 150 * and this information is contained within the first event in the log. 151 * 152 * We calculate the length by examining the number of events, and then looking 153 * at each event in turn to determine how much space is used for events in 154 * total. Once we've done this we know the offset of the data length field, 155 * and can calculate the total size of the event. 156 * 157 * Return: size of the event on success, 0 on failure 158 */ 159 160 static inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *event, 161 struct tcg_pcr_event *event_header, 162 bool do_mapping) 163 { 164 struct tcg_efi_specid_event_head *efispecid; 165 struct tcg_event_field *event_field; 166 void *mapping = NULL; 167 int mapping_size; 168 void *marker; 169 void *marker_start; 170 u32 halg_size; 171 size_t size; 172 u16 halg; 173 int i; 174 int j; 175 u32 count, event_type; 176 const u8 zero_digest[sizeof(event_header->digest)] = {0}; 177 178 marker = event; 179 marker_start = marker; 180 marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type) 181 + sizeof(event->count); 182 183 /* Map the event header */ 184 if (do_mapping) { 185 mapping_size = marker - marker_start; 186 mapping = TPM_MEMREMAP((unsigned long)marker_start, 187 mapping_size); 188 if (!mapping) { 189 size = 0; 190 goto out; 191 } 192 } else { 193 mapping = marker_start; 194 } 195 196 event = (struct tcg_pcr_event2_head *)mapping; 197 /* 198 * The loop below will unmap these fields if the log is larger than 199 * one page, so save them here for reference: 200 */ 201 count = READ_ONCE(event->count); 202 event_type = READ_ONCE(event->event_type); 203 204 /* Verify that it's the log header */ 205 if (event_header->pcr_idx != 0 || 206 event_header->event_type != NO_ACTION || 207 memcmp(event_header->digest, zero_digest, sizeof(zero_digest))) { 208 size = 0; 209 goto out; 210 } 211 212 efispecid = (struct tcg_efi_specid_event_head *)event_header->event; 213 214 /* Check if event is malformed. */ 215 if (memcmp(efispecid->signature, TCG_SPECID_SIG, 216 sizeof(TCG_SPECID_SIG)) || count > efispecid->num_algs) { 217 size = 0; 218 goto out; 219 } 220 221 for (i = 0; i < count; i++) { 222 halg_size = sizeof(event->digests[i].alg_id); 223 224 /* Map the digest's algorithm identifier */ 225 if (do_mapping) { 226 TPM_MEMUNMAP(mapping, mapping_size); 227 mapping_size = halg_size; 228 mapping = TPM_MEMREMAP((unsigned long)marker, 229 mapping_size); 230 if (!mapping) { 231 size = 0; 232 goto out; 233 } 234 } else { 235 mapping = marker; 236 } 237 238 memcpy(&halg, mapping, halg_size); 239 marker = marker + halg_size; 240 241 for (j = 0; j < efispecid->num_algs; j++) { 242 if (halg == efispecid->digest_sizes[j].alg_id) { 243 marker += 244 efispecid->digest_sizes[j].digest_size; 245 break; 246 } 247 } 248 /* Algorithm without known length. Such event is unparseable. */ 249 if (j == efispecid->num_algs) { 250 size = 0; 251 goto out; 252 } 253 } 254 255 /* 256 * Map the event size - we don't read from the event itself, so 257 * we don't need to map it 258 */ 259 if (do_mapping) { 260 TPM_MEMUNMAP(mapping, mapping_size); 261 mapping_size += sizeof(event_field->event_size); 262 mapping = TPM_MEMREMAP((unsigned long)marker, 263 mapping_size); 264 if (!mapping) { 265 size = 0; 266 goto out; 267 } 268 } else { 269 mapping = marker; 270 } 271 272 event_field = (struct tcg_event_field *)mapping; 273 274 marker = marker + sizeof(event_field->event_size) 275 + event_field->event_size; 276 size = marker - marker_start; 277 278 if (event_type == 0 && event_field->event_size == 0) 279 size = 0; 280 281 out: 282 if (do_mapping) 283 TPM_MEMUNMAP(mapping, mapping_size); 284 return size; 285 } 286 287 #endif 288