1
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
10#define ACPI_TCPA_SIG "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
21enum bios_platform_class {
22 BIOS_CLIENT = 0x00,
23 BIOS_SERVER = 0x01,
24};
25
26struct tcpa_event {
27 u32 pcr_index;
28 u32 event_type;
29 u8 pcr_value[20];
30 u32 event_size;
31 u8 event_data[0];
32};
33
34enum 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
55struct tcpa_pc_event {
56 u32 event_id;
57 u32 event_size;
58 u8 event_data[0];
59};
60
61enum 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
78
79struct tcg_efi_specid_event_algs {
80 u16 alg_id;
81 u16 digest_size;
82} __packed;
83
84struct tcg_efi_specid_event_head {
85 u8 signature[16];
86 u32 platform_class;
87 u8 spec_version_minor;
88 u8 spec_version_major;
89 u8 spec_errata;
90 u8 uintnsize;
91 u32 num_algs;
92 struct tcg_efi_specid_event_algs digest_sizes[];
93} __packed;
94
95struct tcg_pcr_event {
96 u32 pcr_idx;
97 u32 event_type;
98 u8 digest[20];
99 u32 event_size;
100 u8 event[0];
101} __packed;
102
103struct tcg_event_field {
104 u32 event_size;
105 u8 event[0];
106} __packed;
107
108struct tcg_pcr_event2_head {
109 u32 pcr_idx;
110 u32 event_type;
111 u32 count;
112 struct tpm_digest digests[];
113} __packed;
114
115struct tcg_algorithm_size {
116 u16 algorithm_id;
117 u16 algorithm_size;
118};
119
120struct tcg_algorithm_info {
121 u8 signature[16];
122 u32 platform_class;
123 u8 spec_version_minor;
124 u8 spec_version_major;
125 u8 spec_errata;
126 u8 uintn_size;
127 u32 number_of_algorithms;
128 struct tcg_algorithm_size digest_sizes[];
129};
130
131#ifndef TPM_MEMREMAP
132#define TPM_MEMREMAP(start, size) NULL
133#endif
134
135#ifndef TPM_MEMUNMAP
136#define TPM_MEMUNMAP(start, size) do{} while(0)
137#endif
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158static inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *event,
159 struct tcg_pcr_event *event_header,
160 bool do_mapping)
161{
162 struct tcg_efi_specid_event_head *efispecid;
163 struct tcg_event_field *event_field;
164 void *mapping = NULL;
165 int mapping_size;
166 void *marker;
167 void *marker_start;
168 u32 halg_size;
169 size_t size;
170 u16 halg;
171 int i;
172 int j;
173 u32 count, event_type;
174
175 marker = event;
176 marker_start = marker;
177 marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type)
178 + sizeof(event->count);
179
180
181 if (do_mapping) {
182 mapping_size = marker - marker_start;
183 mapping = TPM_MEMREMAP((unsigned long)marker_start,
184 mapping_size);
185 if (!mapping) {
186 size = 0;
187 goto out;
188 }
189 } else {
190 mapping = marker_start;
191 }
192
193 event = (struct tcg_pcr_event2_head *)mapping;
194
195
196
197
198 count = READ_ONCE(event->count);
199 event_type = READ_ONCE(event->event_type);
200
201 efispecid = (struct tcg_efi_specid_event_head *)event_header->event;
202
203
204 if (count > efispecid->num_algs) {
205 size = 0;
206 goto out;
207 }
208
209 for (i = 0; i < count; i++) {
210 halg_size = sizeof(event->digests[i].alg_id);
211
212
213 if (do_mapping) {
214 TPM_MEMUNMAP(mapping, mapping_size);
215 mapping_size = halg_size;
216 mapping = TPM_MEMREMAP((unsigned long)marker,
217 mapping_size);
218 if (!mapping) {
219 size = 0;
220 goto out;
221 }
222 } else {
223 mapping = marker;
224 }
225
226 memcpy(&halg, mapping, halg_size);
227 marker = marker + halg_size;
228
229 for (j = 0; j < efispecid->num_algs; j++) {
230 if (halg == efispecid->digest_sizes[j].alg_id) {
231 marker +=
232 efispecid->digest_sizes[j].digest_size;
233 break;
234 }
235 }
236
237 if (j == efispecid->num_algs) {
238 size = 0;
239 goto out;
240 }
241 }
242
243
244
245
246
247 if (do_mapping) {
248 TPM_MEMUNMAP(mapping, mapping_size);
249 mapping_size += sizeof(event_field->event_size);
250 mapping = TPM_MEMREMAP((unsigned long)marker,
251 mapping_size);
252 if (!mapping) {
253 size = 0;
254 goto out;
255 }
256 } else {
257 mapping = marker;
258 }
259
260 event_field = (struct tcg_event_field *)mapping;
261
262 marker = marker + sizeof(event_field->event_size)
263 + event_field->event_size;
264 size = marker - marker_start;
265
266 if (event_type == 0 && event_field->event_size == 0)
267 size = 0;
268
269out:
270 if (do_mapping)
271 TPM_MEMUNMAP(mapping, mapping_size);
272 return size;
273}
274
275#endif
276