| 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 | /* |
| 215 | * Perform validation of the event in order to identify malformed |
| 216 | * events. This function may be asked to parse arbitrary byte sequences |
| 217 | * immediately following a valid event log. The caller expects this |
| 218 | * function to recognize that the byte sequence is not a valid event |
| 219 | * and to return an event size of 0. |
| 220 | */ |
| 221 | if (memcmp(efispecid->signature, TCG_SPECID_SIG, |
| 222 | sizeof(TCG_SPECID_SIG)) || |
| 223 | !efispecid->num_algs || count != efispecid->num_algs) { |
| 224 | size = 0; |
| 225 | goto out; |
| 226 | } |
| 227 | |
| 228 | for (i = 0; i < count; i++) { |
| 229 | halg_size = sizeof(event->digests[i].alg_id); |
| 230 | |
| 231 | /* Map the digest's algorithm identifier */ |
| 232 | if (do_mapping) { |
| 233 | TPM_MEMUNMAP(mapping, mapping_size); |
| 234 | mapping_size = halg_size; |
| 235 | mapping = TPM_MEMREMAP((unsigned long)marker, |
| 236 | mapping_size); |
| 237 | if (!mapping) { |
| 238 | size = 0; |
| 239 | goto out; |
| 240 | } |
| 241 | } else { |
| 242 | mapping = marker; |
| 243 | } |
| 244 | |
| 245 | memcpy(&halg, mapping, halg_size); |
| 246 | marker = marker + halg_size; |
| 247 | |
| 248 | for (j = 0; j < efispecid->num_algs; j++) { |
| 249 | if (halg == efispecid->digest_sizes[j].alg_id) { |
| 250 | marker += |
| 251 | efispecid->digest_sizes[j].digest_size; |
| 252 | break; |
| 253 | } |
| 254 | } |
| 255 | /* Algorithm without known length. Such event is unparseable. */ |
| 256 | if (j == efispecid->num_algs) { |
| 257 | size = 0; |
| 258 | goto out; |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | /* |
| 263 | * Map the event size - we don't read from the event itself, so |
| 264 | * we don't need to map it |
| 265 | */ |
| 266 | if (do_mapping) { |
| 267 | TPM_MEMUNMAP(mapping, mapping_size); |
| 268 | mapping_size += sizeof(event_field->event_size); |
| 269 | mapping = TPM_MEMREMAP((unsigned long)marker, |
| 270 | mapping_size); |
| 271 | if (!mapping) { |
| 272 | size = 0; |
| 273 | goto out; |
| 274 | } |
| 275 | } else { |
| 276 | mapping = marker; |
| 277 | } |
| 278 | |
| 279 | event_field = (struct tcg_event_field *)mapping; |
| 280 | |
| 281 | marker = marker + sizeof(event_field->event_size) |
| 282 | + event_field->event_size; |
| 283 | size = marker - marker_start; |
| 284 | |
| 285 | if (event_type == 0 && event_field->event_size == 0) |
| 286 | size = 0; |
| 287 | |
| 288 | out: |
| 289 | if (do_mapping) |
| 290 | TPM_MEMUNMAP(mapping, mapping_size); |
| 291 | return size; |
| 292 | } |
| 293 | |
| 294 | #endif |