tpm: add securityfs support for TPM 2.0 firmware event log (4d23cc32) · Commits · 戴 / test

drivers/char/tpm/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -3,7 +3,7 @@
	#		#
	obj-$(CONFIG_TCG_TPM) += tpm.o		obj-$(CONFIG_TCG_TPM) += tpm.o
	tpm-y := tpm-interface.o tpm-dev.o tpm-sysfs.o tpm-chip.o tpm2-cmd.o \		tpm-y := tpm-interface.o tpm-dev.o tpm-sysfs.o tpm-chip.o tpm2-cmd.o \
	tpm_eventlog.o		tpm1_eventlog.o tpm2_eventlog.o
	tpm-$(CONFIG_ACPI) += tpm_ppi.o tpm_acpi.o		tpm-$(CONFIG_ACPI) += tpm_ppi.o tpm_acpi.o
	tpm-$(CONFIG_OF) += tpm_of.o		tpm-$(CONFIG_OF) += tpm_of.o
	obj-$(CONFIG_TCG_TIS_CORE) += tpm_tis_core.o		obj-$(CONFIG_TCG_TIS_CORE) += tpm_tis_core.o

drivers/char/tpm/tpm.h

+5 −2

Original line number	Original line	Diff line number	Diff line
	@@ -36,8 +36,6 @@
	#include <linux/highmem.h>		#include <linux/highmem.h>
	#include <crypto/hash_info.h>		#include <crypto/hash_info.h>

	#include "tpm_eventlog.h"

	enum tpm_const {		enum tpm_const {
	TPM_MINOR = 224, /* officially assigned */		TPM_MINOR = 224, /* officially assigned */
	TPM_BUFSIZE = 4096,		TPM_BUFSIZE = 4096,
	@@ -151,6 +149,11 @@ enum tpm_chip_flags {
	TPM_CHIP_FLAG_HAVE_TIMEOUTS = BIT(4),		TPM_CHIP_FLAG_HAVE_TIMEOUTS = BIT(4),
	};		};

			struct tpm_bios_log {
			void *bios_event_log;
			void *bios_event_log_end;
			};

	struct tpm_chip_seqops {		struct tpm_chip_seqops {
	struct tpm_chip *chip;		struct tpm_chip *chip;
	const struct seq_operations *seqops;		const struct seq_operations *seqops;

drivers/char/tpm/tpm_eventlog.c→drivers/char/tpm/tpm1_eventlog.c

+21 −14

Original line number	Original line	Diff line number	Diff line
	@@ -390,9 +390,6 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	unsigned int cnt;		unsigned int cnt;
	int rc = 0;		int rc = 0;

	if (chip->flags & TPM_CHIP_FLAG_TPM2)
	return 0;

	rc = tpm_read_log(chip);		rc = tpm_read_log(chip);
	if (rc)		if (rc)
	return rc;		return rc;
	@@ -407,7 +404,13 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	cnt++;		cnt++;

	chip->bin_log_seqops.chip = chip;		chip->bin_log_seqops.chip = chip;
	chip->bin_log_seqops.seqops = &tpm_binary_b_measurements_seqops;		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] =		chip->bios_dir[cnt] =
	securityfs_create_file("binary_bios_measurements",		securityfs_create_file("binary_bios_measurements",
	@@ -418,8 +421,11 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	goto err;		goto err;
	cnt++;		cnt++;

			if (!(chip->flags & TPM_CHIP_FLAG_TPM2)) {

	chip->ascii_log_seqops.chip = chip;		chip->ascii_log_seqops.chip = chip;
	chip->ascii_log_seqops.seqops = &tpm_ascii_b_measurements_seqops;		chip->ascii_log_seqops.seqops =
			&tpm_ascii_b_measurements_seqops;

	chip->bios_dir[cnt] =		chip->bios_dir[cnt] =
	securityfs_create_file("ascii_bios_measurements",		securityfs_create_file("ascii_bios_measurements",
	@@ -429,6 +435,7 @@ int tpm_bios_log_setup(struct tpm_chip *chip)
	if (IS_ERR(chip->bios_dir[cnt]))		if (IS_ERR(chip->bios_dir[cnt]))
	goto err;		goto err;
	cnt++;		cnt++;
			}

	return 0;		return 0;

drivers/char/tpm/tpm2_eventlog.c

0 → 100644

+203 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2016 IBM Corporation
			*
			* Authors:
			* Nayna Jain <nayna@linux.vnet.ibm.com>
			*
			* Access to TPM 2.0 event log as written by Firmware.
			* It assumes that writer of event log has followed TCG Specification
			* for Family "2.0" and written the event data in little endian.
			* With that, it doesn't need any endian conversion for structure
			* content.
			*
			* 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"

			/*
			* calc_tpm2_event_size() - calculate the event size, where event
			* is an entry in the TPM 2.0 event log. The event is of type Crypto
			* Agile Log Entry Format as defined in TCG EFI Protocol Specification
			* Family "2.0".

			* @event: event whose size is to be calculated.
			* @event_header: the first event in the event log.
			*
			* Returns size of the event. If it is an invalid event, returns 0.
			*/
			static int calc_tpm2_event_size(struct tcg_pcr_event2 *event,
			struct tcg_pcr_event *event_header)
			{
			struct tcg_efi_specid_event *efispecid;
			struct tcg_event_field *event_field;
			void *marker;
			void *marker_start;
			u32 halg_size;
			size_t size;
			u16 halg;
			int i;
			int j;

			marker = event;
			marker_start = marker;
			marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type)
			+ sizeof(event->count);

			efispecid = (struct tcg_efi_specid_event *)event_header->event;

			for (i = 0; (i < event->count) && (i < TPM2_ACTIVE_PCR_BANKS);
			i++) {
			halg_size = sizeof(event->digests[i].alg_id);
			memcpy(&halg, marker, halg_size);
			marker = marker + halg_size;
			for (j = 0; (j < efispecid->num_algs); j++) {
			if (halg == efispecid->digest_sizes[j].alg_id) {
			marker = marker +
			efispecid->digest_sizes[j].digest_size;
			break;
			}
			}
			}

			event_field = (struct tcg_event_field *)marker;
			marker = marker + sizeof(event_field->event_size)
			+ event_field->event_size;
			size = marker - marker_start;

			if ((event->event_type == 0) && (event_field->event_size == 0))
			return 0;

			return size;
			}

			static void tpm2_bios_measurements_start(struct seq_file m, loff_t *pos)
			{
			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 tcg_pcr_event *event_header;
			struct tcg_pcr_event2 *event;
			size_t size;
			int i;

			event_header = addr;
			size = sizeof(struct tcg_pcr_event) - sizeof(event_header->event)
			+ event_header->event_size;

			if (*pos == 0) {
			if (addr + size < limit) {
			if ((event_header->event_type == 0) &&
			(event_header->event_size == 0))
			return NULL;
			return SEQ_START_TOKEN;
			}
			}

			if (*pos > 0) {
			addr += size;
			event = addr;
			size = calc_tpm2_event_size(event, event_header);
			if ((addr + size >= limit) \|\| (size == 0))
			return NULL;
			}

			for (i = 0; i < (*pos - 1); i++) {
			event = addr;
			size = calc_tpm2_event_size(event, event_header);

			if ((addr + size >= limit) \|\| (size == 0))
			return NULL;
			addr += size;
			}

			return addr;
			}

			static void tpm2_bios_measurements_next(struct seq_file m, void *v,
			loff_t *pos)
			{
			struct tcg_pcr_event *event_header;
			struct tcg_pcr_event2 *event;
			struct tpm_chip *chip = m->private;
			struct tpm_bios_log *log = &chip->log;
			void *limit = log->bios_event_log_end;
			size_t event_size;
			void *marker;

			event_header = log->bios_event_log;

			if (v == SEQ_START_TOKEN) {
			event_size = sizeof(struct tcg_pcr_event) -
			sizeof(event_header->event) + event_header->event_size;
			marker = event_header;
			} else {
			event = v;
			event_size = calc_tpm2_event_size(event, event_header);
			if (event_size == 0)
			return NULL;
			marker = event;
			}

			marker = marker + event_size;
			if (marker >= limit)
			return NULL;
			v = marker;
			event = v;

			event_size = calc_tpm2_event_size(event, event_header);
			if (((v + event_size) >= limit) \|\| (event_size == 0))
			return NULL;

			(*pos)++;
			return v;
			}

			static void tpm2_bios_measurements_stop(struct seq_file m, void v)
			{
			}

			static int tpm2_binary_bios_measurements_show(struct seq_file m, void v)
			{
			struct tpm_chip *chip = m->private;
			struct tpm_bios_log *log = &chip->log;
			struct tcg_pcr_event *event_header = log->bios_event_log;
			struct tcg_pcr_event2 *event = v;
			void *temp_ptr;
			size_t size;

			if (v == SEQ_START_TOKEN) {
			size = sizeof(struct tcg_pcr_event) -
			sizeof(event_header->event) + event_header->event_size;

			temp_ptr = event_header;

			if (size > 0)
			seq_write(m, temp_ptr, size);
			} else {
			size = calc_tpm2_event_size(event, event_header);
			temp_ptr = event;
			if (size > 0)
			seq_write(m, temp_ptr, size);
			}

			return 0;
			}

			const struct seq_operations tpm2_binary_b_measurements_seqops = {
			.start = tpm2_bios_measurements_start,
			.next = tpm2_bios_measurements_next,
			.stop = tpm2_bios_measurements_stop,
			.show = tpm2_binary_bios_measurements_show,
			};

drivers/char/tpm/tpm_acpi.c

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -54,6 +54,9 @@ int tpm_read_log_acpi(struct tpm_chip *chip)
	u64 len, start;		u64 len, start;
	struct tpm_bios_log *log;		struct tpm_bios_log *log;

			if (chip->flags & TPM_CHIP_FLAG_TPM2)
			return -ENODEV;

	log = &chip->log;		log = &chip->log;

	/* Unfortuntely ACPI does not associate the event log with a specific		/* Unfortuntely ACPI does not associate the event log with a specific

Admin message