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