mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
297 lines
6.9 KiB
297 lines
6.9 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* Copyright (C) 2005, 2012 IBM Corporation |
|
* |
|
* Authors: |
|
* Kent Yoder <[email protected]> |
|
* Seiji Munetoh <[email protected]> |
|
* Stefan Berger <[email protected]> |
|
* Reiner Sailer <[email protected]> |
|
* Kylene Hall <[email protected]> |
|
* Nayna Jain <[email protected]> |
|
* |
|
* Maintained by: <[email protected]> |
|
* |
|
* Access to the event log created by a system's firmware / BIOS |
|
*/ |
|
|
|
#include <linux/seq_file.h> |
|
#include <linux/efi.h> |
|
#include <linux/fs.h> |
|
#include <linux/security.h> |
|
#include <linux/module.h> |
|
#include <linux/slab.h> |
|
#include <linux/tpm_eventlog.h> |
|
|
|
#include "../tpm.h" |
|
#include "common.h" |
|
|
|
|
|
static const char* tcpa_event_type_strings[] = { |
|
"PREBOOT", |
|
"POST CODE", |
|
"", |
|
"NO ACTION", |
|
"SEPARATOR", |
|
"ACTION", |
|
"EVENT TAG", |
|
"S-CRTM Contents", |
|
"S-CRTM Version", |
|
"CPU Microcode", |
|
"Platform Config Flags", |
|
"Table of Devices", |
|
"Compact Hash", |
|
"IPL", |
|
"IPL Partition Data", |
|
"Non-Host Code", |
|
"Non-Host Config", |
|
"Non-Host Info" |
|
}; |
|
|
|
static const char* tcpa_pc_event_id_strings[] = { |
|
"", |
|
"SMBIOS", |
|
"BIS Certificate", |
|
"POST BIOS ", |
|
"ESCD ", |
|
"CMOS", |
|
"NVRAM", |
|
"Option ROM", |
|
"Option ROM config", |
|
"", |
|
"Option ROM microcode ", |
|
"S-CRTM Version", |
|
"S-CRTM Contents ", |
|
"POST Contents ", |
|
"Table of Devices", |
|
}; |
|
|
|
/* returns pointer to start of pos. entry of tcg log */ |
|
static void *tpm1_bios_measurements_start(struct seq_file *m, loff_t *pos) |
|
{ |
|
loff_t i = 0; |
|
struct tpm_chip *chip = m->private; |
|
struct tpm_bios_log *log = &chip->log; |
|
void *addr = log->bios_event_log; |
|
void *limit = log->bios_event_log_end; |
|
struct tcpa_event *event; |
|
u32 converted_event_size; |
|
u32 converted_event_type; |
|
|
|
/* read over *pos measurements */ |
|
do { |
|
event = addr; |
|
|
|
/* check if current entry is valid */ |
|
if (addr + sizeof(struct tcpa_event) > limit) |
|
return NULL; |
|
|
|
converted_event_size = |
|
do_endian_conversion(event->event_size); |
|
converted_event_type = |
|
do_endian_conversion(event->event_type); |
|
|
|
if (((converted_event_type == 0) && (converted_event_size == 0)) |
|
|| ((addr + sizeof(struct tcpa_event) + converted_event_size) |
|
> limit)) |
|
return NULL; |
|
|
|
if (i++ == *pos) |
|
break; |
|
|
|
addr += (sizeof(struct tcpa_event) + converted_event_size); |
|
} while (1); |
|
|
|
return addr; |
|
} |
|
|
|
static void *tpm1_bios_measurements_next(struct seq_file *m, void *v, |
|
loff_t *pos) |
|
{ |
|
struct tcpa_event *event = v; |
|
struct tpm_chip *chip = m->private; |
|
struct tpm_bios_log *log = &chip->log; |
|
void *limit = log->bios_event_log_end; |
|
u32 converted_event_size; |
|
u32 converted_event_type; |
|
|
|
(*pos)++; |
|
converted_event_size = do_endian_conversion(event->event_size); |
|
|
|
v += sizeof(struct tcpa_event) + converted_event_size; |
|
|
|
/* now check if current entry is valid */ |
|
if ((v + sizeof(struct tcpa_event)) > limit) |
|
return NULL; |
|
|
|
event = v; |
|
|
|
converted_event_size = do_endian_conversion(event->event_size); |
|
converted_event_type = do_endian_conversion(event->event_type); |
|
|
|
if (((converted_event_type == 0) && (converted_event_size == 0)) || |
|
((v + sizeof(struct tcpa_event) + converted_event_size) > limit)) |
|
return NULL; |
|
|
|
return v; |
|
} |
|
|
|
static void tpm1_bios_measurements_stop(struct seq_file *m, void *v) |
|
{ |
|
} |
|
|
|
static int get_event_name(char *dest, struct tcpa_event *event, |
|
unsigned char * event_entry) |
|
{ |
|
const char *name = ""; |
|
/* 41 so there is room for 40 data and 1 nul */ |
|
char data[41] = ""; |
|
int i, n_len = 0, d_len = 0; |
|
struct tcpa_pc_event *pc_event; |
|
|
|
switch (do_endian_conversion(event->event_type)) { |
|
case PREBOOT: |
|
case POST_CODE: |
|
case UNUSED: |
|
case NO_ACTION: |
|
case SCRTM_CONTENTS: |
|
case SCRTM_VERSION: |
|
case CPU_MICROCODE: |
|
case PLATFORM_CONFIG_FLAGS: |
|
case TABLE_OF_DEVICES: |
|
case COMPACT_HASH: |
|
case IPL: |
|
case IPL_PARTITION_DATA: |
|
case NONHOST_CODE: |
|
case NONHOST_CONFIG: |
|
case NONHOST_INFO: |
|
name = tcpa_event_type_strings[do_endian_conversion |
|
(event->event_type)]; |
|
n_len = strlen(name); |
|
break; |
|
case SEPARATOR: |
|
case ACTION: |
|
if (MAX_TEXT_EVENT > |
|
do_endian_conversion(event->event_size)) { |
|
name = event_entry; |
|
n_len = do_endian_conversion(event->event_size); |
|
} |
|
break; |
|
case EVENT_TAG: |
|
pc_event = (struct tcpa_pc_event *)event_entry; |
|
|
|
/* ToDo Row data -> Base64 */ |
|
|
|
switch (do_endian_conversion(pc_event->event_id)) { |
|
case SMBIOS: |
|
case BIS_CERT: |
|
case CMOS: |
|
case NVRAM: |
|
case OPTION_ROM_EXEC: |
|
case OPTION_ROM_CONFIG: |
|
case S_CRTM_VERSION: |
|
name = tcpa_pc_event_id_strings[do_endian_conversion |
|
(pc_event->event_id)]; |
|
n_len = strlen(name); |
|
break; |
|
/* hash data */ |
|
case POST_BIOS_ROM: |
|
case ESCD: |
|
case OPTION_ROM_MICROCODE: |
|
case S_CRTM_CONTENTS: |
|
case POST_CONTENTS: |
|
name = tcpa_pc_event_id_strings[do_endian_conversion |
|
(pc_event->event_id)]; |
|
n_len = strlen(name); |
|
for (i = 0; i < 20; i++) |
|
d_len += sprintf(&data[2*i], "%02x", |
|
pc_event->event_data[i]); |
|
break; |
|
default: |
|
break; |
|
} |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]", |
|
n_len, name, d_len, data); |
|
|
|
} |
|
|
|
static int tpm1_binary_bios_measurements_show(struct seq_file *m, void *v) |
|
{ |
|
struct tcpa_event *event = v; |
|
struct tcpa_event temp_event; |
|
char *temp_ptr; |
|
int i; |
|
|
|
memcpy(&temp_event, event, sizeof(struct tcpa_event)); |
|
|
|
/* convert raw integers for endianness */ |
|
temp_event.pcr_index = do_endian_conversion(event->pcr_index); |
|
temp_event.event_type = do_endian_conversion(event->event_type); |
|
temp_event.event_size = do_endian_conversion(event->event_size); |
|
|
|
temp_ptr = (char *) &temp_event; |
|
|
|
for (i = 0; i < (sizeof(struct tcpa_event) - 1) ; i++) |
|
seq_putc(m, temp_ptr[i]); |
|
|
|
temp_ptr = (char *) v; |
|
|
|
for (i = (sizeof(struct tcpa_event) - 1); |
|
i < (sizeof(struct tcpa_event) + temp_event.event_size); i++) |
|
seq_putc(m, temp_ptr[i]); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
static int tpm1_ascii_bios_measurements_show(struct seq_file *m, void *v) |
|
{ |
|
int len = 0; |
|
char *eventname; |
|
struct tcpa_event *event = v; |
|
unsigned char *event_entry = |
|
(unsigned char *)(v + sizeof(struct tcpa_event)); |
|
|
|
eventname = kmalloc(MAX_TEXT_EVENT, GFP_KERNEL); |
|
if (!eventname) { |
|
printk(KERN_ERR "%s: ERROR - No Memory for event name\n ", |
|
__func__); |
|
return -EFAULT; |
|
} |
|
|
|
/* 1st: PCR */ |
|
seq_printf(m, "%2d ", do_endian_conversion(event->pcr_index)); |
|
|
|
/* 2nd: SHA1 */ |
|
seq_printf(m, "%20phN", event->pcr_value); |
|
|
|
/* 3rd: event type identifier */ |
|
seq_printf(m, " %02x", do_endian_conversion(event->event_type)); |
|
|
|
len += get_event_name(eventname, event, event_entry); |
|
|
|
/* 4th: eventname <= max + \'0' delimiter */ |
|
seq_printf(m, " %s\n", eventname); |
|
|
|
kfree(eventname); |
|
return 0; |
|
} |
|
|
|
const struct seq_operations tpm1_ascii_b_measurements_seqops = { |
|
.start = tpm1_bios_measurements_start, |
|
.next = tpm1_bios_measurements_next, |
|
.stop = tpm1_bios_measurements_stop, |
|
.show = tpm1_ascii_bios_measurements_show, |
|
}; |
|
|
|
const struct seq_operations tpm1_binary_b_measurements_seqops = { |
|
.start = tpm1_bios_measurements_start, |
|
.next = tpm1_bios_measurements_next, |
|
.stop = tpm1_bios_measurements_stop, |
|
.show = tpm1_binary_bios_measurements_show, |
|
};
|
|
|