mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-16 14:06:48 +07:00
fd5c78694f
When TPM2 log has entries with more than 3 digests, or with digests
not listed in the log header, log gets misparsed, eventually
leading to kernel complaint that code tried to vmalloc 512MB of
memory (I have no idea what would happen on bigger system).
So code should not parse only first 3 digests: both event header
and event itself are already in memory, so we can parse any number
of digests, as long as we do not try to parse whole memory when
given count of 0xFFFFFFFF.
So this change:
* Rejects event entry with more digests than log header describes.
Digest types should be unique, and all should be described in
log header, so there cannot be more digests in the event than in
the header.
* Reject event entry with digest that is not described in the
log header. In theory code could hardcode information about
digest IDs already assigned by TCG, but if firmware authors
cannot get event log format right, why should anyone believe
that they got event log content right.
Cc: stable@vger.kernel.org
Fixes: 4d23cc323c
("tpm: add securityfs support for TPM 2.0 firmware event log")
Signed-off-by: Petr Vandrovec <petr@vmware.com>
Reviewed-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
Signed-off-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com>
210 lines
5.2 KiB
C
210 lines
5.2 KiB
C
/*
|
|
* 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;
|
|
|
|
/* Check if event is malformed. */
|
|
if (event->count > efispecid->num_algs)
|
|
return 0;
|
|
|
|
for (i = 0; i < event->count; 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 +=
|
|
efispecid->digest_sizes[j].digest_size;
|
|
break;
|
|
}
|
|
}
|
|
/* Algorithm without known length. Such event is unparseable. */
|
|
if (j == efispecid->num_algs)
|
|
return 0;
|
|
}
|
|
|
|
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,
|
|
};
|