~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/tpm_eventlog.h

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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
295 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp