mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Nayna Jain](/assets/img/avatar_default.png)
Unlike the device driver support for TPM 1.2, the TPM 2.0 does not support the securityfs pseudo files for displaying the firmware event log. This patch enables support for providing the TPM 2.0 event log in binary form. TPM 2.0 event log supports a crypto agile format that records multiple digests, which is different from TPM 1.2. This patch enables the tpm_bios_log_setup for TPM 2.0 and adds the event log parser which understand the TPM 2.0 crypto agile format. Signed-off-by: Nayna Jain <nayna@linux.vnet.ibm.com> Reviewed-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> Tested-by: Kenneth Goldman <kgold@linux.vnet.ibm.com> Tested-by: Stefan Berger <stefanb@linux.vnet.ibm.com> Signed-off-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
469 lines
11 KiB
C
469 lines
11 KiB
C
/*
|
|
* Copyright (C) 2005, 2012 IBM Corporation
|
|
*
|
|
* Authors:
|
|
* Kent Yoder <key@linux.vnet.ibm.com>
|
|
* Seiji Munetoh <munetoh@jp.ibm.com>
|
|
* Stefan Berger <stefanb@us.ibm.com>
|
|
* Reiner Sailer <sailer@watson.ibm.com>
|
|
* Kylene Hall <kjhall@us.ibm.com>
|
|
* Nayna Jain <nayna@linux.vnet.ibm.com>
|
|
*
|
|
* Maintained by: <tpmdd-devel@lists.sourceforge.net>
|
|
*
|
|
* Access to the event log created by a system's firmware / BIOS
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
*/
|
|
|
|
#include <linux/seq_file.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/security.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "tpm.h"
|
|
#include "tpm_eventlog.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 *tpm_bios_measurements_start(struct seq_file *m, loff_t *pos)
|
|
{
|
|
loff_t i;
|
|
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 */
|
|
for (i = 0; i < *pos; i++) {
|
|
event = addr;
|
|
|
|
converted_event_size =
|
|
do_endian_conversion(event->event_size);
|
|
converted_event_type =
|
|
do_endian_conversion(event->event_type);
|
|
|
|
if ((addr + sizeof(struct tcpa_event)) < limit) {
|
|
if ((converted_event_type == 0) &&
|
|
(converted_event_size == 0))
|
|
return NULL;
|
|
addr += (sizeof(struct tcpa_event) +
|
|
converted_event_size);
|
|
}
|
|
}
|
|
|
|
/* now check if current entry is valid */
|
|
if ((addr + sizeof(struct tcpa_event)) >= limit)
|
|
return NULL;
|
|
|
|
event = addr;
|
|
|
|
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;
|
|
|
|
return addr;
|
|
}
|
|
|
|
static void *tpm_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;
|
|
|
|
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;
|
|
|
|
(*pos)++;
|
|
return v;
|
|
}
|
|
|
|
static void tpm_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;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return snprintf(dest, MAX_TEXT_EVENT, "[%.*s%.*s]",
|
|
n_len, name, d_len, data);
|
|
|
|
}
|
|
|
|
static int tpm_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 tpm_bios_measurements_release(struct inode *inode,
|
|
struct file *file)
|
|
{
|
|
struct seq_file *seq = (struct seq_file *)file->private_data;
|
|
struct tpm_chip *chip = (struct tpm_chip *)seq->private;
|
|
|
|
put_device(&chip->dev);
|
|
|
|
return seq_release(inode, file);
|
|
}
|
|
|
|
static int tpm_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;
|
|
}
|
|
|
|
static const struct seq_operations tpm_ascii_b_measurements_seqops = {
|
|
.start = tpm_bios_measurements_start,
|
|
.next = tpm_bios_measurements_next,
|
|
.stop = tpm_bios_measurements_stop,
|
|
.show = tpm_ascii_bios_measurements_show,
|
|
};
|
|
|
|
static const struct seq_operations tpm_binary_b_measurements_seqops = {
|
|
.start = tpm_bios_measurements_start,
|
|
.next = tpm_bios_measurements_next,
|
|
.stop = tpm_bios_measurements_stop,
|
|
.show = tpm_binary_bios_measurements_show,
|
|
};
|
|
|
|
static int tpm_bios_measurements_open(struct inode *inode,
|
|
struct file *file)
|
|
{
|
|
int err;
|
|
struct seq_file *seq;
|
|
struct tpm_chip_seqops *chip_seqops;
|
|
const struct seq_operations *seqops;
|
|
struct tpm_chip *chip;
|
|
|
|
inode_lock(inode);
|
|
if (!inode->i_private) {
|
|
inode_unlock(inode);
|
|
return -ENODEV;
|
|
}
|
|
chip_seqops = (struct tpm_chip_seqops *)inode->i_private;
|
|
seqops = chip_seqops->seqops;
|
|
chip = chip_seqops->chip;
|
|
get_device(&chip->dev);
|
|
inode_unlock(inode);
|
|
|
|
/* now register seq file */
|
|
err = seq_open(file, seqops);
|
|
if (!err) {
|
|
seq = file->private_data;
|
|
seq->private = chip;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static const struct file_operations tpm_bios_measurements_ops = {
|
|
.owner = THIS_MODULE,
|
|
.open = tpm_bios_measurements_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = tpm_bios_measurements_release,
|
|
};
|
|
|
|
static int tpm_read_log(struct tpm_chip *chip)
|
|
{
|
|
int rc;
|
|
|
|
if (chip->log.bios_event_log != NULL) {
|
|
dev_dbg(&chip->dev,
|
|
"%s: ERROR - event log already initialized\n",
|
|
__func__);
|
|
return -EFAULT;
|
|
}
|
|
|
|
rc = tpm_read_log_acpi(chip);
|
|
if (rc != -ENODEV)
|
|
return rc;
|
|
|
|
return tpm_read_log_of(chip);
|
|
}
|
|
|
|
/*
|
|
* tpm_bios_log_setup() - Read the event log from the firmware
|
|
* @chip: TPM chip to use.
|
|
*
|
|
* If an event log is found then the securityfs files are setup to
|
|
* export it to userspace, otherwise nothing is done.
|
|
*
|
|
* Returns -ENODEV if the firmware has no event log or securityfs is not
|
|
* supported.
|
|
*/
|
|
int tpm_bios_log_setup(struct tpm_chip *chip)
|
|
{
|
|
const char *name = dev_name(&chip->dev);
|
|
unsigned int cnt;
|
|
int rc = 0;
|
|
|
|
rc = tpm_read_log(chip);
|
|
if (rc)
|
|
return rc;
|
|
|
|
cnt = 0;
|
|
chip->bios_dir[cnt] = securityfs_create_dir(name, NULL);
|
|
/* NOTE: securityfs_create_dir can return ENODEV if securityfs is
|
|
* compiled out. The caller should ignore the ENODEV return code.
|
|
*/
|
|
if (IS_ERR(chip->bios_dir[cnt]))
|
|
goto err;
|
|
cnt++;
|
|
|
|
chip->bin_log_seqops.chip = chip;
|
|
if (chip->flags & TPM_CHIP_FLAG_TPM2)
|
|
chip->bin_log_seqops.seqops =
|
|
&tpm2_binary_b_measurements_seqops;
|
|
else
|
|
chip->bin_log_seqops.seqops =
|
|
&tpm_binary_b_measurements_seqops;
|
|
|
|
|
|
chip->bios_dir[cnt] =
|
|
securityfs_create_file("binary_bios_measurements",
|
|
0440, chip->bios_dir[0],
|
|
(void *)&chip->bin_log_seqops,
|
|
&tpm_bios_measurements_ops);
|
|
if (IS_ERR(chip->bios_dir[cnt]))
|
|
goto err;
|
|
cnt++;
|
|
|
|
if (!(chip->flags & TPM_CHIP_FLAG_TPM2)) {
|
|
|
|
chip->ascii_log_seqops.chip = chip;
|
|
chip->ascii_log_seqops.seqops =
|
|
&tpm_ascii_b_measurements_seqops;
|
|
|
|
chip->bios_dir[cnt] =
|
|
securityfs_create_file("ascii_bios_measurements",
|
|
0440, chip->bios_dir[0],
|
|
(void *)&chip->ascii_log_seqops,
|
|
&tpm_bios_measurements_ops);
|
|
if (IS_ERR(chip->bios_dir[cnt]))
|
|
goto err;
|
|
cnt++;
|
|
}
|
|
|
|
return 0;
|
|
|
|
err:
|
|
rc = PTR_ERR(chip->bios_dir[cnt]);
|
|
chip->bios_dir[cnt] = NULL;
|
|
tpm_bios_log_teardown(chip);
|
|
return rc;
|
|
}
|
|
|
|
void tpm_bios_log_teardown(struct tpm_chip *chip)
|
|
{
|
|
int i;
|
|
struct inode *inode;
|
|
|
|
/* securityfs_remove currently doesn't take care of handling sync
|
|
* between removal and opening of pseudo files. To handle this, a
|
|
* workaround is added by making i_private = NULL here during removal
|
|
* and to check it during open(), both within inode_lock()/unlock().
|
|
* This design ensures that open() either safely gets kref or fails.
|
|
*/
|
|
for (i = (TPM_NUM_EVENT_LOG_FILES - 1); i >= 0; i--) {
|
|
if (chip->bios_dir[i]) {
|
|
inode = d_inode(chip->bios_dir[i]);
|
|
inode_lock(inode);
|
|
inode->i_private = NULL;
|
|
inode_unlock(inode);
|
|
securityfs_remove(chip->bios_dir[i]);
|
|
}
|
|
}
|
|
}
|