Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __LINUX_TPM_EVENTLOG_H__#define __LINUX_TPM_EVENTLOG_H__
#include <linux/tpm.h>
#define TCG_EVENT_NAME_LEN_MAX 255#define MAX_TEXT_EVENT 1000 /* Max event string length */#define ACPI_TCPA_SIG "TCPA" /* 0x41504354 /'TCPA' */
#define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 0x1#define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2 0x2
#ifdef CONFIG_PPC64#define do_endian_conversion(x) be32_to_cpu(x)#else#define do_endian_conversion(x) x#endif
enum bios_platform_class { BIOS_CLIENT = 0x00, BIOS_SERVER = 0x01,};
struct tcpa_event { u32 pcr_index; u32 event_type; u8 pcr_value[20]; /* SHA1 */ u32 event_size; u8 event_data[];};
enum tcpa_event_types { PREBOOT = 0, POST_CODE, UNUSED, NO_ACTION, SEPARATOR, ACTION, EVENT_TAG, SCRTM_CONTENTS, SCRTM_VERSION, CPU_MICROCODE, PLATFORM_CONFIG_FLAGS, TABLE_OF_DEVICES, COMPACT_HASH, IPL, IPL_PARTITION_DATA, NONHOST_CODE, NONHOST_CONFIG, NONHOST_INFO,};
struct tcpa_pc_event { u32 event_id; u32 event_size; u8 event_data[];};
enum tcpa_pc_event_ids { SMBIOS = 1, BIS_CERT, POST_BIOS_ROM, ESCD, CMOS, NVRAM, OPTION_ROM_EXEC, OPTION_ROM_CONFIG, OPTION_ROM_MICROCODE = 10, S_CRTM_VERSION, S_CRTM_CONTENTS, POST_CONTENTS, HOST_TABLE_OF_DEVICES,};
/* http://www.trustedcomputinggroup.org/tcg-efi-protocol-specification/ */
struct tcg_efi_specid_event_algs { u16 alg_id; u16 digest_size;} __packed;
#define TCG_SPECID_SIG "Spec ID Event03"
struct tcg_efi_specid_event_head { u8 signature[16]; u32 platform_class; u8 spec_version_minor; u8 spec_version_major; u8 spec_errata; u8 uintnsize; u32 num_algs; struct tcg_efi_specid_event_algs digest_sizes[];} __packed;
struct tcg_pcr_event { u32 pcr_idx; u32 event_type; u8 digest[20]; u32 event_size; u8 event[];} __packed;
struct tcg_event_field { u32 event_size; u8 event[];} __packed;
struct tcg_pcr_event2_head { u32 pcr_idx; u32 event_type; u32 count; struct tpm_digest digests[];} __packed;
struct tcg_algorithm_size { u16 algorithm_id; u16 algorithm_size;};
struct tcg_algorithm_info { u8 signature[16]; u32 platform_class; u8 spec_version_minor; u8 spec_version_major; u8 spec_errata; u8 uintn_size; u32 number_of_algorithms; struct tcg_algorithm_size digest_sizes[];};
#ifndef TPM_MEMREMAPstatic inline void *TPM_MEMREMAP(unsigned long start, size_t size){ return NULL;}#endif
#ifndef TPM_MEMUNMAPstatic inline void TPM_MEMUNMAP(void *mapping, size_t size){}#endif
/** * __calc_tpm2_event_size - calculate the size of a TPM2 event log entry * @event: Pointer to the event whose size should be calculated * @event_header: Pointer to the initial event containing the digest lengths * @do_mapping: Whether or not the event needs to be mapped * * The TPM2 event log format can contain multiple digests corresponding to * separate PCR banks, and also contains a variable length of the data that * was measured. This requires knowledge of how long each digest type is, * and this information is contained within the first event in the log. * * We calculate the length by examining the number of events, and then looking * at each event in turn to determine how much space is used for events in * total. Once we've done this we know the offset of the data length field, * and can calculate the total size of the event. * * Return: size of the event on success, 0 on failure */
static __always_inline u32 __calc_tpm2_event_size(struct tcg_pcr_event2_head *event, struct tcg_pcr_event *event_header, bool do_mapping){ struct tcg_efi_specid_event_head *efispecid; struct tcg_event_field *event_field; void *mapping = NULL; int mapping_size; void *marker; void *marker_start; u32 halg_size; size_t size; u16 halg; int i; int j; u32 count, event_type; const u8 zero_digest[sizeof(event_header->digest)] = {0};
marker = event; marker_start = marker; marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type) + sizeof(event->count);
/* Map the event header */ if (do_mapping) { mapping_size = marker - marker_start; mapping = TPM_MEMREMAP((unsigned long)marker_start, mapping_size); if (!mapping) { size = 0; goto out; } } else { mapping = marker_start; }
event = (struct tcg_pcr_event2_head *)mapping; /* * The loop below will unmap these fields if the log is larger than * one page, so save them here for reference: */ count = event->count; event_type = event->event_type;
/* Verify that it's the log header */ if (event_header->pcr_idx != 0 || event_header->event_type != NO_ACTION || memcmp(event_header->digest, zero_digest, sizeof(zero_digest))) { size = 0; goto out; }
efispecid = (struct tcg_efi_specid_event_head *)event_header->event;
/* * Perform validation of the event in order to identify malformed * events. This function may be asked to parse arbitrary byte sequences * immediately following a valid event log. The caller expects this * function to recognize that the byte sequence is not a valid event * and to return an event size of 0. */ if (memcmp(efispecid->signature, TCG_SPECID_SIG, sizeof(TCG_SPECID_SIG)) || !efispecid->num_algs || count != efispecid->num_algs) { size = 0; goto out; }
for (i = 0; i < count; i++) { halg_size = sizeof(event->digests[i].alg_id);
/* Map the digest's algorithm identifier */ if (do_mapping) { TPM_MEMUNMAP(mapping, mapping_size); mapping_size = halg_size; mapping = TPM_MEMREMAP((unsigned long)marker, mapping_size); if (!mapping) { size = 0; goto out; } } else { mapping = marker; }
memcpy(&halg, mapping, halg_size); marker = marker + halg_size;
for (j = 0; j < efispecid->num_algs; j++) { if (halg == efispecid->digest_sizes[j].alg_id) { marker += efispecid->digest_sizes[j].digest_size; break; } } /* Algorithm without known length. Such event is unparseable. */ if (j == efispecid->num_algs) { size = 0; goto out; } }
/* * Map the event size - we don't read from the event itself, so * we don't need to map it */ if (do_mapping) { TPM_MEMUNMAP(mapping, mapping_size); mapping_size += sizeof(event_field->event_size); mapping = TPM_MEMREMAP((unsigned long)marker, mapping_size); if (!mapping) { size = 0; goto out; } } else { mapping = marker; }
event_field = (struct tcg_event_field *)mapping;
marker = marker + sizeof(event_field->event_size) + event_field->event_size; size = marker - marker_start;
if (event_type == 0 && event_field->event_size == 0) size = 0;
out: if (do_mapping) TPM_MEMUNMAP(mapping, mapping_size); return size;}
#endif