Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
e5dcd87f | 2 | |
fd3ec366 TW |
3 | #ifndef __LINUX_TPM_EVENTLOG_H__ |
4 | #define __LINUX_TPM_EVENTLOG_H__ | |
e5dcd87f | 5 | |
aa042475 | 6 | #include <linux/tpm.h> |
4d23cc32 | 7 | |
e5dcd87f KY |
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 | ||
4d01d29d TW |
12 | #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 0x1 |
13 | #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2 0x2 | |
14 | ||
0cc698af HCVL |
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 | ||
e5dcd87f KY |
21 | enum bios_platform_class { |
22 | BIOS_CLIENT = 0x00, | |
23 | BIOS_SERVER = 0x01, | |
24 | }; | |
25 | ||
e5dcd87f KY |
26 | struct tcpa_event { |
27 | u32 pcr_index; | |
28 | u32 event_type; | |
29 | u8 pcr_value[20]; /* SHA1 */ | |
30 | u32 event_size; | |
06ccf63d | 31 | u8 event_data[]; |
e5dcd87f KY |
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; | |
06ccf63d | 58 | u8 event_data[]; |
e5dcd87f KY |
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 | ||
4d23cc32 NJ |
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 | ||
7dfc06a0 FV |
84 | #define TCG_SPECID_SIG "Spec ID Event03" |
85 | ||
c8faabfc | 86 | struct tcg_efi_specid_event_head { |
4d23cc32 NJ |
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; | |
c8faabfc | 94 | struct tcg_efi_specid_event_algs digest_sizes[]; |
4d23cc32 NJ |
95 | } __packed; |
96 | ||
97 | struct tcg_pcr_event { | |
98 | u32 pcr_idx; | |
99 | u32 event_type; | |
100 | u8 digest[20]; | |
101 | u32 event_size; | |
ab91c2a8 | 102 | u8 event[]; |
4d23cc32 NJ |
103 | } __packed; |
104 | ||
105 | struct tcg_event_field { | |
106 | u32 event_size; | |
06ccf63d | 107 | u8 event[]; |
4d23cc32 NJ |
108 | } __packed; |
109 | ||
c8faabfc | 110 | struct tcg_pcr_event2_head { |
4d23cc32 NJ |
111 | u32 pcr_idx; |
112 | u32 event_type; | |
113 | u32 count; | |
aa042475 | 114 | struct tpm_digest digests[]; |
4d23cc32 NJ |
115 | } __packed; |
116 | ||
c46f3405 MG |
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 | ||
44038bc5 MG |
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 | |
c46f3405 | 145 | * @do_mapping: Whether or not the event needs to be mapped |
44038bc5 MG |
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 | * | |
e658c82b | 157 | * Return: size of the event on success, 0 on failure |
44038bc5 MG |
158 | */ |
159 | ||
bed45936 | 160 | static __always_inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *event, |
c46f3405 MG |
161 | struct tcg_pcr_event *event_header, |
162 | bool do_mapping) | |
44038bc5 MG |
163 | { |
164 | struct tcg_efi_specid_event_head *efispecid; | |
165 | struct tcg_event_field *event_field; | |
c46f3405 MG |
166 | void *mapping = NULL; |
167 | int mapping_size; | |
44038bc5 MG |
168 | void *marker; |
169 | void *marker_start; | |
170 | u32 halg_size; | |
171 | size_t size; | |
172 | u16 halg; | |
173 | int i; | |
174 | int j; | |
047d50ae | 175 | u32 count, event_type; |
7dfc06a0 | 176 | const u8 zero_digest[sizeof(event_header->digest)] = {0}; |
44038bc5 MG |
177 | |
178 | marker = event; | |
179 | marker_start = marker; | |
180 | marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type) | |
181 | + sizeof(event->count); | |
182 | ||
c46f3405 MG |
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; | |
047d50ae PJ |
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); | |
c46f3405 | 203 | |
7dfc06a0 FV |
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 | ||
44038bc5 MG |
212 | efispecid = (struct tcg_efi_specid_event_head *)event_header->event; |
213 | ||
7f3d176f TH |
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 | */ | |
7dfc06a0 | 221 | if (memcmp(efispecid->signature, TCG_SPECID_SIG, |
7f3d176f TH |
222 | sizeof(TCG_SPECID_SIG)) || |
223 | !efispecid->num_algs || count != efispecid->num_algs) { | |
c46f3405 MG |
224 | size = 0; |
225 | goto out; | |
226 | } | |
44038bc5 | 227 | |
047d50ae | 228 | for (i = 0; i < count; i++) { |
44038bc5 | 229 | halg_size = sizeof(event->digests[i].alg_id); |
c46f3405 MG |
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); | |
44038bc5 | 246 | marker = marker + halg_size; |
c46f3405 | 247 | |
44038bc5 MG |
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. */ | |
c46f3405 MG |
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; | |
44038bc5 MG |
277 | } |
278 | ||
c46f3405 MG |
279 | event_field = (struct tcg_event_field *)mapping; |
280 | ||
44038bc5 MG |
281 | marker = marker + sizeof(event_field->event_size) |
282 | + event_field->event_size; | |
283 | size = marker - marker_start; | |
284 | ||
047d50ae | 285 | if (event_type == 0 && event_field->event_size == 0) |
c46f3405 | 286 | size = 0; |
047d50ae | 287 | |
c46f3405 MG |
288 | out: |
289 | if (do_mapping) | |
290 | TPM_MEMUNMAP(mapping, mapping_size); | |
44038bc5 MG |
291 | return size; |
292 | } | |
c46f3405 | 293 | |
e5dcd87f | 294 | #endif |