xref: /openbmc/linux/include/linux/tpm_eventlog.h (revision d3f45053)
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 
__calc_tpm2_event_size(struct tcg_pcr_event2_head * event,struct tcg_pcr_event * event_header,bool do_mapping)160 static __always_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 = event->count;
202 	event_type = 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
295