From: niuyongwen &lt;niuyongwen(a)hygon.cn&gt; TDM（Trusted Dynamic Measurement) is a module designed and implemented by HYGON in its X86 CPU's embeded secure processor, providing dynamical measurement service to X86 side aiming at memory that needs to be protected, e.g. the memory area kernel code resides. With this new feature, the goal of protecting any specified memory dynamically in the runtime can be achieved. When the protected memory is modified illegally, TDM will detect the event immediately and give an alarm in the form of an exception, meantime, the abnormal information is recorded inside the TDM for subsequent audit or remote attestation. The TDM driver mainly implements the following functions: (1) Send the required memory block information and configuration information to TDM device for protection; (2) Manage the further distribution of exceptions when TDM detects illegal memory modification and an exception is triggered. (3) Record abnormal information for subsequent audit or attestation. Signed-off-by: niuyongwen &lt;niuyongwen(a)hygon.cn&gt; Change-Id: I5d86931a6cced6653e3fc4b1976be0d2e1f5a7f5 --- drivers/crypto/ccp/Kconfig | 8 + drivers/crypto/ccp/Makefile | 2 + drivers/crypto/ccp/tdm_hygon.c | 1004 ++++++++++++++++++++++++++++++++ drivers/crypto/ccp/tdm_hygon.h | 111 ++++ 4 files changed, 1125 insertions(+) create mode 100644 drivers/crypto/ccp/tdm_hygon.c create mode 100644 drivers/crypto/ccp/tdm_hygon.h diff --git a/drivers/crypto/ccp/Kconfig b/drivers/crypto/ccp/Kconfig index fc9cdfc72706..74a48b453bf7 100644 --- a/drivers/crypto/ccp/Kconfig +++ b/drivers/crypto/ccp/Kconfig @@ -52,3 +52,11 @@ config HYGON_PSP2CPU_CMD depends on CRYPTO_DEV_SP_PSP help Hygon PSP2CPU Command Support + +config TDM_HYGON + tristate "Hygon TDM Interface" + default y + depends on CRYPTO_DEV_CCP_DD + depends on HYGON_PSP2CPU_CMD + help + Hygon TDM driver diff --git a/drivers/crypto/ccp/Makefile b/drivers/crypto/ccp/Makefile index 51d1c0cf66c7..0fdfd913272c 100644 --- a/drivers/crypto/ccp/Makefile +++ b/drivers/crypto/ccp/Makefile @@ -19,3 +19,5 @@ ccp-crypto-objs := ccp-crypto-main.o \ ccp-crypto-des3.o \ ccp-crypto-rsa.o \ ccp-crypto-sha.o + +obj-$(CONFIG_TDM_HYGON) += tdm_hygon.o diff --git a/drivers/crypto/ccp/tdm_hygon.c b/drivers/crypto/ccp/tdm_hygon.c new file mode 100644 index 000000000000..fda129cd7353 --- /dev/null +++ b/drivers/crypto/ccp/tdm_hygon.c @@ -0,0 +1,1004 @@ +/* + * The Hygon TDM CPU-to-PSP communication driver + * + * Copyright (C) 2018 Hygon Info Technologies Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ +#include <linux/module.h> +#include <linux/psp-sev.h> +#include <linux/spinlock.h> +#include <linux/rwlock.h> +#include <linux/err.h> +#include <asm/current.h> +#include <linux/kthread.h> +#include <linux/list.h> +#include <linux/delay.h> +#include <linux/kfifo.h> +#include <linux/scatterlist.h> +#include <crypto/hash.h> +#include "tdm_hygon.h" + +#define TDM_CMD_ID_MAX 16 +#define TDM2PSP_CMD(id) (0x110 | (id)) +#define TDM_INT_CMD_ID 1 +#define TDM_KFIFO_SIZE 1024 + +struct context_message { + uint32_t context_flag; + uint32_t pid; + uint8_t comm[16]; + uint8_t module_name[64]; +}; + +typedef struct tdm_task_head { + struct list_head head; + rwlock_t lock; +} tdm_task_head_t; + +typedef struct dynamic_task_node { + uint32_t task_id; + uint32_t context_flag; + measure_exception_handler_t handler; + struct list_head list; +} dynamic_task_node_t; + +static tdm_task_head_t dyn_head; +static unsigned int cmd_id = TDM_INT_CMD_ID; +static struct task_struct *kthread; +static DECLARE_KFIFO(kfifo_error_task, unsigned char, TDM_KFIFO_SIZE); +static spinlock_t kfifo_lock; + +#ifdef SEV_API_ADDR_CALL +typedef int (*psp_do_cmd_t)(int cmd, void *data, int *psp_ret); +/*(psp_do_cmd_t)0xffffffffc054c940;*/ +psp_do_cmd_t psp_do_cmd; +static unsigned long psp_do_cmd_addr; +module_param(psp_do_cmd_addr, ulong, 0444); +MODULE_PARM_DESC(psp_do_cmd_addr, "Addr of unexported kernel API psp_do_cmd"); +#endif + +enum X86_TO_PSP_CMD { + TASK_CREATE = 0x0, + TASK_VERIFY_AUTH, + TASK_QUERY, + TASK_DESTROY, + TASK_UPDATE, + TASK_STOP, + TASK_START, + TDM_VERSION +}; + +static int list_check_exist(uint32_t task_id) +{ + int found = 0; + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + + head = &dyn_head.head; + lock = &dyn_head.lock; + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + if (task_node->task_id == task_id) { + found = 1; + break; + } + } + read_unlock(lock); + + return found; +} + +static int list_enqueue(void *entry) +{ + struct list_head *head, *entry_list = NULL; + rwlock_t *lock = NULL; + + if (!entry) { + pr_err("Null pointer\n"); + return -DYN_NULL_POINTER; + } + + head = &dyn_head.head; + lock = &dyn_head.lock; + entry_list = &(((dynamic_task_node_t *)entry)->list); + + write_lock(lock); + if (entry_list) + list_add_tail(entry_list, head); + write_unlock(lock); + + return 0; +} + +static __maybe_unused int list_print(void) +{ + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + + head = &dyn_head.head; + lock = &dyn_head.lock; + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + pr_info("id: %d ", task_node->task_id); + } + read_unlock(lock); + pr_info("\n"); + + return 0; +} + +static void __maybe_unused print_buf(uint8_t *buf, int len) +{ + int i = 0; + + for (i = 0; i < len; i++) { + pr_info("0x%02x ", buf[i]); + if ((i + 1)%16 == 0) + pr_info("\n"); + } + pr_info("\n"); +} + +static int measure_exception_handling_thread(void *data) +{ + int ret = 0; + int copied = 0; + uint32_t error_task_id = 0xffffffff; + struct measure_status task_measure_status; + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + + head = &dyn_head.head; + lock = &dyn_head.lock; + + pr_info("Thread started for measurement exception handler dispatching...\n"); + while (!kthread_should_stop()) { + set_current_state(TASK_INTERRUPTIBLE); + schedule(); + + while (!kfifo_is_empty(&kfifo_error_task)) { + copied = kfifo_out_spinlocked(&kfifo_error_task, (unsigned char *)&error_task_id, sizeof(uint32_t), &kfifo_lock); + if (copied != sizeof(uint32_t)) { + ret = -DYN_ERR_API; + pr_err("kfifio_out exception,return\n"); + goto end; + } + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + if (task_node->task_id == error_task_id) + break; + } + read_unlock(lock); + + if (!task_node) { + ret = -DYN_NULL_POINTER; + pr_err("task_node is null,return\n"); + goto end; + } + + if (task_node->task_id == error_task_id) { + if (task_node->handler) { + pr_info("-----Measurement exception handler dispatching thread------\n"); + pr_info("Measurement exception received for task %d\n", error_task_id); + pr_info("Step1: Query PSP for task %d status to confirm the error.\n", error_task_id); + pr_info("Step2: Error confirmed, CALL measurement exception handler.\n"); + ret = psp_query_measure_status(error_task_id, &task_measure_status); + if (ret) { + pr_err("task_id %d status query failed\n", error_task_id); + goto end; + } + + if (task_measure_status.error == MER_ERR) { //error--1 normal--0 + pr_info("Error detected for task %d, action TODO!\n", error_task_id); + pr_info("-------Measurement exception handler----------\n"); + task_node->handler(error_task_id); + pr_info("Exit measurement exception handler.\n"); + } else { + pr_info("No error detected for task %d, please check it again!\n", error_task_id); + } + } else { + pr_err("task %d's callback function is not registered, please check it\n", error_task_id); + } + } + } + } +end: + return ret; +} + +static int tdm_interrupt_handler(uint32_t id, uint64_t data) +{ + if (kthread) { + kfifo_in_spinlocked(&kfifo_error_task, (unsigned char *)&data, sizeof(uint32_t), &kfifo_lock); + wake_up_process(kthread); + } + + return 0; +} + +static int tdm_do_cmd(unsigned int cmd_id, void *cmd_data, int *error) +{ + if (cmd_id >= TDM_CMD_ID_MAX) { + pr_err("%s cmd_id %u beyond limit\n", __func__, cmd_id); + return -DYN_BEYOND_MAX; + } + + return psp_do_cmd(TDM2PSP_CMD(cmd_id), cmd_data, error); +} + +static int calc_task_context_hash(struct context_message context_msg, uint8_t *hash) +{ + int ret = 0; + struct crypto_shash *shash = NULL; + + if (!hash) { + pr_err("%s invalid address\n", __func__); + return -DYN_NULL_POINTER; + } + + shash = crypto_alloc_shash("sha256", 0, 0); + if (IS_ERR(shash)) { + pr_err("can't alloc hash\n"); + return -DYN_ERR_API; + } + + { + SHASH_DESC_ON_STACK(sdesc, shash); + + sdesc->tfm = shash; + sdesc->flags = 0; + + ret = crypto_shash_init(sdesc); + if (ret) { + pr_err("crypto_shash_init failed\n"); + ret = -DYN_ERR_API; + goto out; + } + + if (context_msg.context_flag & CONTEXT_CHECK_PID) { + ret = crypto_shash_update(sdesc, (uint8_t *)&context_msg.pid, sizeof(context_msg.pid)); + if (ret) { + pr_err("crypto_shash_update failed\n"); + ret = -DYN_ERR_API; + goto out; + } + } + + if (context_msg.context_flag & CONTEXT_CHECK_COMM) { + ret = crypto_shash_update(sdesc, context_msg.comm, strlen(context_msg.comm)); + if (ret) { + pr_err("crypto_shash_update failed\n"); + ret = -DYN_ERR_API; + goto out; + } + } + + if (context_msg.context_flag & CONTEXT_CHECK_MODNAME) { + ret = crypto_shash_update(sdesc, context_msg.module_name, strlen(context_msg.module_name)); + if (ret) { + pr_err("crypto_shash_update failed\n"); + ret = -DYN_ERR_API; + goto out; + } + } + + ret = crypto_shash_final(sdesc, hash); + if (ret) { + pr_err("crypto_shash_final failed\n"); + ret = -DYN_ERR_API; + goto out; + } + } + +out: + crypto_free_shash(shash); + return ret; +} + +int psp_get_fw_info(struct tdm_version *version) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t x86_cmd_type = 0; + + if (!version) { + pr_err("version is null pointer\n"); + return -DYN_NULL_POINTER; + } + + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = TDM_VERSION; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("get_fw_info exception error: 0x%x\n", error); + ret = -error; + goto end; + } + + //1B--type 4B--task-id 2B--measure status + p = cmd_data; + memcpy(version, p, sizeof(struct tdm_version)); + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_get_fw_info); + +int psp_create_measure_task(struct addr_range_info *range, struct measure_data *data, uint32_t context_check_flag, struct authcode_2b *code) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t new_task_id = 0; + uint32_t addr_range_info_len = 0; + uint32_t x86_cmd_type = 0; + uint16_t authcode_len = 0; + uint8_t context_hash[32] = {0}; + struct context_message context_msg; + struct list_head *head = NULL; + dynamic_task_node_t *task_node = NULL; + unsigned long return_address = 0; + struct module *p_module = NULL; + + if ((!range) || (!data) || (!code)) { + pr_err("%s invalid address\n", __func__); + return -DYN_NULL_POINTER; + } + + if (range->count > RANGE_CNT_MAX) { + pr_err("%s range->count %d is beyond RANGE_CNT_MAX %d\n ", __func__, range->count, RANGE_CNT_MAX); + return -DYN_BEYOND_MAX; + } + + /*addr_range_info_len--4B addr_info measure_data--40B*/ + /*authcode_len--2B context_hash--32B*/ + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + addr_range_info_len = range->count*sizeof(struct addr_info) + sizeof(struct addr_range_info); + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = TASK_CREATE; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(p, range, addr_range_info_len); + p += addr_range_info_len; + memcpy(p, data, sizeof(struct measure_data)); + p += sizeof(struct measure_data); + authcode_len = code->len > AUTHCODE_MAX ? AUTHCODE_MAX : code->len; + memcpy(p, &authcode_len, sizeof(authcode_len)); + p += sizeof(authcode_len); + + context_msg.context_flag = context_check_flag; + context_msg.pid = current->pid; + memcpy(context_msg.comm, current->comm, sizeof(current->comm)); + return_address = (unsigned long)__builtin_return_address(0); + p_module = __module_address(return_address); + //module + if (p_module) + memcpy(context_msg.module_name, p_module->name, sizeof(p_module->name)); + //build-in + else + memset(context_msg.module_name, 0, sizeof(context_msg.module_name)); + + ret = calc_task_context_hash(context_msg, context_hash); + if (ret) { + pr_err("calc_task_context_hash failed\n"); + goto end; + } + + memcpy(p, context_hash, sizeof(context_hash)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("create_measure_task exception error: 0x%x\n", error); + ret = -error; + goto end; + } + + //get new assigned id from cmd_data + p = cmd_data; + memcpy(&x86_cmd_type, p, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(&new_task_id, p, sizeof(new_task_id)); + p += sizeof(new_task_id); + memcpy(&code->len, p, sizeof(code->len)); + p += sizeof(code->len); + code->len = code->len > AUTHCODE_MAX ? AUTHCODE_MAX : code->len; + memcpy(&code->val[0], p, code->len); + + head = &dyn_head.head; + task_node = kzalloc(sizeof(dynamic_task_node_t), GFP_KERNEL); + if (!task_node) { + pr_err("%s kzalloc for size %ld failed\n", __func__, sizeof(dynamic_task_node_t)); + kfree(cmd_data); + return -DYN_ERR_MEM; + } + + task_node->task_id = new_task_id; + task_node->handler = NULL; + task_node->context_flag = context_check_flag; + + ret = list_enqueue(task_node); + if (ret) { + pr_err("task %d enqueue failed!!!\n", new_task_id); + kfree(task_node); + goto end; + } + + kfree(cmd_data); + + return new_task_id; + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_create_measure_task); + +int psp_query_measure_status(uint32_t task_id, struct measure_status *status) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t x86_cmd_type = 0; + + if (!status) { + pr_err("status is null pointer\n"); + return -DYN_NULL_POINTER; + } + + if (!list_check_exist(task_id)) { + pr_err("task %d isn't created\n", task_id); + return -DYN_NOT_EXIST; + } + + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = TASK_QUERY; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(p, &task_id, sizeof(task_id)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("query_measure_task exception error: 0x%x\n", error); + ret = -error; + goto end; + } + + //1B--type 4B--task-id 2B--measure status + p = cmd_data; + p += sizeof(x86_cmd_type) + sizeof(task_id); + memcpy(status, p, sizeof(struct measure_status)); + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_query_measure_status); + +int psp_register_measure_exception_handler(uint32_t task_id, struct authcode_2b *code, measure_exception_handler_t handler) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t x86_cmd_type = 0; + uint8_t context_hash[32] = {0}; + struct context_message context_msg; + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + unsigned long return_address = 0; + struct module *p_module = NULL; + + if (!code) { + pr_err("%s invalid authcode\n", __func__); + return -DYN_NULL_POINTER; + } + + if (code->len > AUTHCODE_MAX) { + pr_err("%s authcode len %d is beyond AUTHCODE_MAX %d\n", __func__, code->len, AUTHCODE_MAX); + return -DYN_BEYOND_MAX; + } + + if (!list_check_exist(task_id)) { + pr_err("task %d isn't created\n", task_id); + return -DYN_NOT_EXIST; + } + //check if task_id is registered already + head = &dyn_head.head; + lock = &dyn_head.lock; + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + if (task_node->task_id == task_id) { + if ((handler && task_node->handler)) { + pr_err("task %d is registered already\n", task_id); + read_unlock(lock); + return -DYN_EEXIST; + } + break;//task_node will be used for next context + } + } + read_unlock(lock); + + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = TASK_VERIFY_AUTH; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(p, &task_id, sizeof(task_id)); + p += sizeof(task_id); + memcpy(p, &code->len, sizeof(code->len)); + p += sizeof(code->len); + memcpy(p, code->val, code->len); + p += AUTHCODE_MAX; + + context_msg.context_flag = task_node->context_flag; + context_msg.pid = current->pid; + memcpy(context_msg.comm, current->comm, sizeof(current->comm)); + return_address = (unsigned long)__builtin_return_address(0); + + p_module = __module_address(return_address); + //module + if (p_module) + memcpy(context_msg.module_name, p_module->name, sizeof(p_module->name)); + //build-in + else + memset(context_msg.module_name, 0, sizeof(context_msg.module_name)); + + ret = calc_task_context_hash(context_msg, context_hash); + if (ret) { + pr_err("calc_task_context_hash failed\n"); + goto end; + } + + memcpy(p, context_hash, sizeof(context_hash)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("register_measure_task exception error: 0x%x\n", error); + ret = -error; + goto end; + } + + write_lock(lock); + task_node->handler = handler; + write_unlock(lock); + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_register_measure_exception_handler); + +int psp_destroy_measure_task(uint32_t task_id, struct authcode_2b *code) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t x86_cmd_type = 0; + uint8_t context_hash[32] = {0}; + struct context_message context_msg; + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + unsigned long return_address = 0; + struct module *p_module = NULL; + + if (!code) { + pr_err("%s invalid authcode\n", __func__); + return -DYN_NULL_POINTER; + } + + if (code->len > AUTHCODE_MAX) { + pr_err("%s authcode len %d is beyond AUTHCODE_MAX %d\n", __func__, code->len, AUTHCODE_MAX); + return -DYN_BEYOND_MAX; + } + + if (!list_check_exist(task_id)) { + pr_err("task %d isn't created\n", task_id); + return -DYN_NOT_EXIST; + } + + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = TASK_DESTROY; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(p, &task_id, sizeof(task_id)); + p += sizeof(task_id); + memcpy(p, &code->len, sizeof(code->len)); + p += sizeof(code->len); + memcpy(p, code->val, code->len); + p += AUTHCODE_MAX; + + head = &dyn_head.head; + lock = &dyn_head.lock; + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + if (task_node->task_id == task_id) + break; + } + read_unlock(lock); + + context_msg.context_flag = task_node->context_flag; + context_msg.pid = current->pid; + memcpy(context_msg.comm, current->comm, sizeof(current->comm)); + return_address = (unsigned long)__builtin_return_address(0); + + p_module = __module_address(return_address); + if (p_module) + memcpy(context_msg.module_name, p_module->name, sizeof(p_module->name)); + else + memset(context_msg.module_name, 0, sizeof(context_msg.module_name)); + + ret = calc_task_context_hash(context_msg, context_hash); + if (ret) { + pr_err("calc_task_context_hash failed\n"); + goto end; + } + + memcpy(p, context_hash, sizeof(context_hash)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("destroy_measure_task exception error: 0x%x\n", error); + ret = -error; + goto end; + } + + if (task_node->handler) { + write_lock(lock); + task_node->handler = NULL; + write_unlock(lock); + } + + write_lock(lock); + list_del(&task_node->list); + write_unlock(lock); + + kfree(task_node); + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_destroy_measure_task); + +int psp_update_measure_task(uint32_t task_id, struct authcode_2b *code, struct measure_update_data *data) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t x86_cmd_type = 0; + uint8_t context_hash[32] = {0}; + struct context_message context_msg; + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + unsigned long return_address = 0; + struct module *p_module = NULL; + + if ((!data) || (!code)) { + pr_err("%s invalid address\n", __func__); + return -DYN_NULL_POINTER; + } + + if (code->len > AUTHCODE_MAX) { + pr_err("%s authcode len %d is beyond AUTHCODE_MAX %d\n", __func__, code->len, AUTHCODE_MAX); + return -DYN_BEYOND_MAX; + } + + if (!list_check_exist(task_id)) { + pr_err("task %d isn't created\n", task_id); + return -DYN_NOT_EXIST; + } + + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = TASK_UPDATE; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(p, &task_id, sizeof(task_id)); + p += sizeof(task_id); + memcpy(p, &code->len, sizeof(code->len)); + p += sizeof(code->len); + memcpy(p, code->val, code->len); + p += AUTHCODE_MAX;//Fixed allocation of 16 bytes of memory for authcode + + head = &dyn_head.head; + lock = &dyn_head.lock; + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + if (task_node->task_id == task_id) + break; + } + read_unlock(lock); + + context_msg.context_flag = task_node->context_flag; + context_msg.pid = current->pid; + memcpy(context_msg.comm, current->comm, sizeof(current->comm)); + return_address = (unsigned long)__builtin_return_address(0); + + p_module = __module_address(return_address); + if (p_module) + memcpy(context_msg.module_name, p_module->name, sizeof(p_module->name)); + else + memset(context_msg.module_name, 0, sizeof(context_msg.module_name)); + + ret = calc_task_context_hash(context_msg, context_hash); + if (ret) { + pr_err("calc_task_context_hash failed\n"); + goto end; + } + + memcpy(p, context_hash, sizeof(context_hash)); + p += sizeof(context_hash); + memcpy(p, data, sizeof(struct measure_update_data)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("update_measure_task exception error: 0x%x\n", error); + ret = -error; + goto end; + } + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_update_measure_task); + +int psp_startstop_measure_task(uint32_t task_id, struct authcode_2b *code, bool start) +{ + int ret = 0; + unsigned char *cmd_data; + unsigned char *p; + int error; + uint32_t x86_cmd_type = 0; + uint8_t context_hash[32] = {0}; + struct context_message context_msg; + struct list_head *head = NULL; + rwlock_t *lock = NULL; + dynamic_task_node_t *task_node = NULL, *tmp_node = NULL; + unsigned long return_address = 0; + struct module *p_module = NULL; + struct measure_status receive_measure_status; + + if (!code) { + pr_err("%s invalid authcode\n", __func__); + return -DYN_NULL_POINTER; + } + + if (code->len > AUTHCODE_MAX) { + pr_err("%s authcode len %d is beyond AUTHCODE_MAX %d\n", __func__, code->len, AUTHCODE_MAX); + return -DYN_BEYOND_MAX; + } + + if (!list_check_exist(task_id)) { + pr_err("task %d isn't created\n", task_id); + return -DYN_NOT_EXIST; + } + + cmd_data = kzalloc(PAGE_SIZE, GFP_KERNEL); + if (!cmd_data) { + pr_err("%s kzalloc for size %ld failed\n", __func__, PAGE_SIZE); + return -DYN_ERR_MEM; + } + + /*0--create 1--verify_auth 2--query 3--destroy 4--update 5--stop 6-start*/ + x86_cmd_type = start ? TASK_START : TASK_STOP; + p = cmd_data; + memcpy(p, &x86_cmd_type, sizeof(x86_cmd_type)); + p += sizeof(x86_cmd_type); + memcpy(p, &task_id, sizeof(task_id)); + p += sizeof(task_id); + memcpy(p, &code->len, sizeof(code->len)); + p += sizeof(code->len); + memcpy(p, code->val, code->len); + p += AUTHCODE_MAX; + + head = &dyn_head.head; + lock = &dyn_head.lock; + + read_lock(lock); + list_for_each_entry_safe(task_node, tmp_node, head, list) { + if (task_node->task_id == task_id) + break; + } + read_unlock(lock); + + context_msg.context_flag = task_node->context_flag; + context_msg.pid = current->pid; + memcpy(context_msg.comm, current->comm, sizeof(current->comm)); + return_address = (unsigned long)__builtin_return_address(0); + + p_module = __module_address(return_address); + if (p_module) + memcpy(context_msg.module_name, p_module->name, sizeof(p_module->name)); + else + memset(context_msg.module_name, 0, sizeof(context_msg.module_name)); + + ret = calc_task_context_hash(context_msg, context_hash); + if (ret) { + pr_err("calc_task_context_hash failed\n"); + goto end; + } + + memcpy(p, context_hash, sizeof(context_hash)); + + ret = tdm_do_cmd(cmd_id, cmd_data, &error); + if (ret && ret != -EIO) { + pr_err("psp_do_cmd failed cmd 0x%x\n", TDM2PSP_CMD(cmd_id)); + goto end; + } + + if (error) { + pr_err("startstop_measure_task exception error: 0x%x\n", error); + ret = -error; + goto end; + } + + p = cmd_data; + p += sizeof(x86_cmd_type) + sizeof(task_id); + memcpy(&receive_measure_status, p, sizeof(struct measure_status)); + + kfree(cmd_data); + + return receive_measure_status.status; + +end: + kfree(cmd_data); + + return ret; +} +EXPORT_SYMBOL_GPL(psp_startstop_measure_task); + +static int __init _module_init(void) +{ + int ret = 0; + + INIT_KFIFO(kfifo_error_task); + INIT_LIST_HEAD(&dyn_head.head); + rwlock_init(&dyn_head.lock); + spin_lock_init(&kfifo_lock); + +#ifdef SEV_API_ADDR_CALL + pr_info("psp_do_cmd_addr 0x%lx\n", psp_do_cmd_addr); + if (!psp_do_cmd_addr) { + pr_err("Please specify param: psp_do_cmd_addr\n"); + return -DYN_NULL_POINTER; + } + + psp_do_cmd = (psp_do_cmd_t)psp_do_cmd_addr; +#endif + + ret = psp_register_cmd_notifier(cmd_id, tdm_interrupt_handler); + if (ret) { + pr_err("notifier function registration failed\n"); + return ret; + } + + kthread = kthread_create(measure_exception_handling_thread, NULL, "measure_exception_handling_thread"); + if (IS_ERR(kthread)) { + pr_err("kthread_create fail\n"); + ret = PTR_ERR(kthread); + return ret; + } + + wake_up_process(kthread); + + return 0; +} + +static void __exit _module_exit(void) +{ + if (kthread) { + kthread_stop(kthread); + kthread = NULL; + } + + psp_unregister_cmd_notifier(cmd_id, tdm_interrupt_handler); +} + +MODULE_AUTHOR(&quot;niuyongwen(a)hygon.cn&quot;).cn"); +MODULE_LICENSE("GPL"); +MODULE_VERSION("0.1"); +MODULE_DESCRIPTION("The dynamic measure driver"); + +module_init(_module_init); +module_exit(_module_exit); diff --git a/drivers/crypto/ccp/tdm_hygon.h b/drivers/crypto/ccp/tdm_hygon.h new file mode 100644 index 000000000000..80d9c34e0fd9 --- /dev/null +++ b/drivers/crypto/ccp/tdm_hygon.h @@ -0,0 +1,111 @@ +/* + * The Hygon TDM CPU-to-PSP communication driver + * + * Copyright (C) 2018 Hygon Info Technologies Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ +#ifndef __TDM_HYGON_H__ +#define __TDM_HYGON_H__ + +#include <linux/sched.h> + +#define RANGE_CNT_MAX 0x80 +#define MEASURE_TASK_MAX 100 +#define AUTHCODE_MAX 16 +#define AUTH_TRY_DELAY 1 + +#define HASH_ALGO_SM3 0 +#define HASH_ALGO_SHA1 1 +#define HASH_ALGO_SHA256 2 +#define HASH_ALGO_SHA384 3 + +#define CONTEXT_CHECK_PID 0x1 +#define CONTEXT_CHECK_COMM 0x2 +#define CONTEXT_CHECK_MODNAME 0x4 + +#define MEASURE_UPDATE_ALGO 0x1 +#define MEASURE_UPDATE_EXPECTED_MEASUREMENT 0x2 +#define MEASURE_UPDATE_PERIOD 0x4 + +enum TDM_TASK_STATUS { + DYN_INIT = 0x0, + DYN_TO_RUN, + DYN_RUN, + DYN_TO_STOP, + DYN_STOP +}; + +enum TDM_MEASURE_STATUS { + MER_NORMAL = 0x0, + MER_ERR +}; + +enum DYN_ERROR_TYPE { + DYN_NORMAL = 0x0, + DYN_NOT_EXIST, + DYN_AUTH_FAIL, + DYN_STATUS_NOT_SUIT, + DYN_BEYOND_MAX, + DYN_DA_PERIOD, + DYN_NULL_POINTER, + DYN_ERR_API, + DYN_EEXIST, + DYN_ERR_MEM, + DYN_ERR_AUTH_LEN +}; + +struct addr_info { + uint64_t phy_addr; + uint64_t length; +} __attribute__((packed)); + +struct addr_range_info { + uint32_t count; + struct addr_info addr[0]; +} __attribute__((packed)); + +struct measure_data { + uint32_t hash_algo; + uint8_t expected_measurement[32]; + uint32_t period_ms; +} __attribute__((packed)); + +struct authcode_2b { + uint16_t len; + uint8_t val[0]; +} __attribute__((packed)); + +struct measure_status { + uint8_t status; + uint8_t error; + uint8_t count; +} __attribute__((packed)); + +struct measure_update_data { + uint32_t update_flag; + uint32_t algo; + uint8_t expected_measurement[32]; + uint32_t period_ms; +} __attribute__((packed)); + +struct tdm_version { + uint8_t api_major; + uint8_t api_minor; + uint32_t buildId; + uint32_t task_max; + uint32_t range_max_per_task; +} __attribute__((packed)); + +typedef int (*measure_exception_handler_t)(uint32_t task_id); + +int psp_get_fw_info(struct tdm_version *version); +int psp_create_measure_task(struct addr_range_info *range, struct measure_data *data, uint32_t context_check_flag, struct authcode_2b *code); +int psp_query_measure_status(uint32_t task_id, struct measure_status *status); +int psp_register_measure_exception_handler(uint32_t task_id, struct authcode_2b *code, measure_exception_handler_t handler); +int psp_destroy_measure_task(uint32_t task_id, struct authcode_2b *code); +int psp_update_measure_task(uint32_t task_id, struct authcode_2b *code, struct measure_update_data *data); +int psp_startstop_measure_task(uint32_t task_id, struct authcode_2b *code, bool start); +#endif /* __TDM_HYGON_H__*/ -- 2.17.1

From: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Hygon CPU implemented a firmware-based TPM2 device, which runs on its internal secure processor named PSP. The device is fully compatible with TCG TPM2.0 spec (part 1 ~ 4) in the commands level, but underlying uses an unique private interface in the form of some hardware mailbox between X86 cores and PSP, which is for sure different from the TIS or CRB interfaces defined in the PTP spec. As such, to support this device we need a specialized driver which handles the basic send and receive operations required by the kernel TPM core layer. ACPI device info passed from underlying BIOS indicates the device presence by setting the _HID field (see TCG ACPI Sepcification, Family 1.2 and 2.0, Chapter 8 "ACPI Device") to "HYGT0101", which distinguishes it from the rest of devices. If the BIOS does not support this setting, the driver will not be activated and thus has no impact to the system at all. Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: I18fb935eedcbc5467ba1589fc7a85b5953d741d9 --- drivers/char/tpm/Kconfig | 11 +++ drivers/char/tpm/Makefile | 1 + drivers/char/tpm/tpm_hygon.c | 187 +++++++++++++++++++++++++++++++++++ 3 files changed, 199 insertions(+) create mode 100644 drivers/char/tpm/tpm_hygon.c diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig index 18c81cbe4704..490045af1cbf 100644 --- a/drivers/char/tpm/Kconfig +++ b/drivers/char/tpm/Kconfig @@ -164,6 +164,17 @@ config TCG_VTPM_PROXY /dev/vtpmX and a server-side file descriptor on which the vTPM can receive commands. +config TCG_HYGON + tristate "Hygon TPM Interface" + depends on ACPI + depends on CRYPTO_DEV_CCP_DD + depends on CRYPTO_DEV_SP_PSP + default y + ---help--- + If you want to make Hygon TPM support available, say Yes and + it will be accessible from within Linux. To compile this + driver as a module, choose M here; the module will be called + tpm_hygon. source "drivers/char/tpm/st33zp24/Kconfig" endif # TCG_TPM diff --git a/drivers/char/tpm/Makefile b/drivers/char/tpm/Makefile index 4e9c33ca1f8f..f01c601b37d0 100644 --- a/drivers/char/tpm/Makefile +++ b/drivers/char/tpm/Makefile @@ -23,3 +23,4 @@ obj-$(CONFIG_TCG_TIS_ST33ZP24) += st33zp24/ obj-$(CONFIG_TCG_XEN) += xen-tpmfront.o obj-$(CONFIG_TCG_CRB) += tpm_crb.o obj-$(CONFIG_TCG_VTPM_PROXY) += tpm_vtpm_proxy.o +obj-$(CONFIG_TCG_HYGON) += tpm_hygon.o diff --git a/drivers/char/tpm/tpm_hygon.c b/drivers/char/tpm/tpm_hygon.c new file mode 100644 index 000000000000..7fad553b6699 --- /dev/null +++ b/drivers/char/tpm/tpm_hygon.c @@ -0,0 +1,187 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * The Hygon TPM2.0 device driver. + * + * Copyright (C) 2020 Hygon Info Technologies Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/types.h> +#include <linux/uaccess.h> +#include <linux/err.h> +#include <linux/psp-sev.h> +#include <linux/platform_device.h> +#include <linux/pm.h> +#include <linux/tpm.h> +#include "tpm.h" + +#define TPM2PSP_CMD(id) (0x100 | (id)) +#define MAX_TPM_BUF_LEN 4096 +#define MAX_CMD_BUF_LEN (MAX_TPM_BUF_LEN + sizeof(u32) + sizeof(u32)) + +struct tpm_hygon_priv { + u8 priv_buf[MAX_CMD_BUF_LEN]; +}; + +/* + * tpm header struct name is different in different kernel versions. + * so redefine it for driver porting. + */ +struct tpm_header_t { + __be16 tag; + __be32 length; + union { + __be32 ordinal; + __be32 return_code; + }; +} __packed; + +static int tpm_c_recv(struct tpm_chip *chip, u8 *buf, size_t count) +{ + int ret = 0; + struct tpm_hygon_priv *priv = dev_get_drvdata(&chip->dev); + struct tpm_header_t *header = (void *)(priv->priv_buf + sizeof(u32) + sizeof(u32)); + u32 len = be32_to_cpu(header->length); + + if (len > count) { + ret = -E2BIG; + goto out; + } + + if (len > 0) + memmove(buf, (u8 *)header, len); + + ret = len; + +out: + return ret; +} + +static int tpm_c_send(struct tpm_chip *chip, u8 *buf, size_t count) +{ + int ret, error; + struct tpm_hygon_priv *priv = dev_get_drvdata(&chip->dev); + u32 buf_size = cpu_to_be32(sizeof(priv->priv_buf)); + u32 cmd_size = cpu_to_be32((u32)count); + u8 *p = priv->priv_buf; + + *(u32 *)p = buf_size; + p += sizeof(buf_size); + *(u32 *)p = cmd_size; + p += sizeof(cmd_size); + memmove(p, buf, count); + + ret = psp_do_cmd(TPM2PSP_CMD(0), priv->priv_buf, &error); + if (ret) { + pr_err("%s: sev do cmd error, %d\n", __func__, error); + ret = -EIO; + } + + return ret; +} + +static const struct tpm_class_ops tpm_c_ops = { + .flags = TPM_OPS_AUTO_STARTUP, + .recv = tpm_c_recv, + .send = tpm_c_send, +}; + +static int hygon_tpm2_acpi_add(struct acpi_device *device) +{ + int ret; + struct tpm_chip *chip; + struct tpm_hygon_priv *priv; + struct device *dev = &device->dev; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) { + ret = -ENOMEM; + goto err; + } + + chip = tpmm_chip_alloc(dev, &tpm_c_ops); + if (IS_ERR(chip)) { + pr_err("tpmm_chip_alloc fail\n"); + ret = PTR_ERR(chip); + goto err; + } + + dev_set_drvdata(&chip->dev, priv); + + chip->flags |= TPM_CHIP_FLAG_TPM2; + chip->flags |= TPM_CHIP_FLAG_IRQ; + + ret = tpm_chip_register(chip); + if (ret) { + pr_err("tpm_chip_register fail\n"); + goto err; + } + + pr_info("Hygon TPM2 detected\n"); + + return 0; + +err: + return ret; +} + +static int hygon_tpm2_acpi_remove(struct acpi_device *device) +{ + struct device *dev = &device->dev; + struct tpm_chip *chip = dev_get_drvdata(dev); + + tpm_chip_unregister(chip); + + pr_info("Hygon TPM2 removed\n"); + return 0; +} + +static SIMPLE_DEV_PM_OPS(tpm_hygon_pm, tpm_pm_suspend, tpm_pm_resume); + +static const struct acpi_device_id hygon_tpm2_device_ids[] = { + {"HYGT0101", 0}, + {"", 0}, +}; + +MODULE_DEVICE_TABLE(acpi, hygon_tpm2_device_ids); + +static struct acpi_driver hygon_tpm2_acpi_driver = { + .name = "tpm_hygon", + .ids = hygon_tpm2_device_ids, + .ops = { + .add = hygon_tpm2_acpi_add, + .remove = hygon_tpm2_acpi_remove, + }, + .drv = { + .pm = &tpm_hygon_pm, + }, +}; + +static int __init hygon_tpm2_init(void) +{ + return acpi_bus_register_driver(&hygon_tpm2_acpi_driver); +} + +static void __exit hygon_tpm2_exit(void) +{ + acpi_bus_unregister_driver(&hygon_tpm2_acpi_driver); +} + +/* + * hygon_tpm2_init must be done after ccp module init, but before + * ima module init. That's why we use a device_initcall_sync which is + * called after all the device_initcall(includes ccp) but before the + * late_initcall(includes ima). + */ +device_initcall_sync(hygon_tpm2_init); +module_exit(hygon_tpm2_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("mayuanchen (mayuanchen(a)hygon.cn)&quot;)uot;); +MODULE_DESCRIPTION("TPM2 device driver for Hygon PSP"); -- 2.17.1

From: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; commit c8faabfc6f48009fb0d9ad4203aecfa569e5ff8d upstream. TCG defines two structures, TCG_EfiSpecIDEventStruct and TCG_PCR_EVENT2, which contain variable-sized arrays in the middle of the definition. Since these structures are not suitable for type casting, this patch removes structure members after the variable-sized arrays and adds the _head suffix to the structure name, to indicate that the renamed structures do not contain all fields defined by TCG. Lastly, given that variable-sized arrays are now in the last position, and given that the size of the arrays cannot be determined in advance, this patch also sets the size of those arrays to zero and removes the definition of TPM2_ACTIVE_PCR_BANKS. Signed-off-by: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; Reviewed-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Tested-by: Nayna Jain &lt;nayna(a)linux.ibm.com&gt; Signed-off-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: Ie36a99b8c25c8a3118c223f4d9bf033eddfef033 --- drivers/char/tpm/eventlog/tpm2.c | 12 ++++++------ include/linux/tpm_eventlog.h | 12 ++++-------- 2 files changed, 10 insertions(+), 14 deletions(-) diff --git a/drivers/char/tpm/eventlog/tpm2.c b/drivers/char/tpm/eventlog/tpm2.c index 41b9f6c92da7..f824563fc28d 100644 --- a/drivers/char/tpm/eventlog/tpm2.c +++ b/drivers/char/tpm/eventlog/tpm2.c @@ -37,10 +37,10 @@ * * Returns size of the event. If it is an invalid event, returns 0. */ -static size_t calc_tpm2_event_size(struct tcg_pcr_event2 *event, +static size_t calc_tpm2_event_size(struct tcg_pcr_event2_head *event, struct tcg_pcr_event *event_header) { - struct tcg_efi_specid_event *efispecid; + struct tcg_efi_specid_event_head *efispecid; struct tcg_event_field *event_field; void *marker; void *marker_start; @@ -55,7 +55,7 @@ static size_t calc_tpm2_event_size(struct tcg_pcr_event2 *event, marker = marker + sizeof(event->pcr_idx) + sizeof(event->event_type) + sizeof(event->count); - efispecid = (struct tcg_efi_specid_event *)event_header->event; + efispecid = (struct tcg_efi_specid_event_head *)event_header->event; /* Check if event is malformed. */ if (event->count > efispecid->num_algs) @@ -95,7 +95,7 @@ static void *tpm2_bios_measurements_start(struct seq_file *m, loff_t *pos) void *addr = log->bios_event_log; void *limit = log->bios_event_log_end; struct tcg_pcr_event *event_header; - struct tcg_pcr_event2 *event; + struct tcg_pcr_event2_head *event; size_t size; int i; @@ -136,7 +136,7 @@ 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 tcg_pcr_event2_head *event; struct tpm_chip *chip = m->private; struct tpm_bios_log *log = &chip->log; void *limit = log->bios_event_log_end; @@ -180,7 +180,7 @@ 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; + struct tcg_pcr_event2_head *event = v; void *temp_ptr; size_t size; diff --git a/include/linux/tpm_eventlog.h b/include/linux/tpm_eventlog.h index 20d9da77fc11..f47342361e87 100644 --- a/include/linux/tpm_eventlog.h +++ b/include/linux/tpm_eventlog.h @@ -8,7 +8,6 @@ #define TCG_EVENT_NAME_LEN_MAX 255 #define MAX_TEXT_EVENT 1000 /* Max event string length */ #define ACPI_TCPA_SIG "TCPA" /* 0x41504354 /'TCPA' */ -#define TPM2_ACTIVE_PCR_BANKS 3 #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 0x1 #define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2 0x2 @@ -82,7 +81,7 @@ struct tcg_efi_specid_event_algs { u16 digest_size; } __packed; -struct tcg_efi_specid_event { +struct tcg_efi_specid_event_head { u8 signature[16]; u32 platform_class; u8 spec_version_minor; @@ -90,9 +89,7 @@ struct tcg_efi_specid_event { u8 spec_errata; u8 uintnsize; u32 num_algs; - struct tcg_efi_specid_event_algs digest_sizes[TPM2_ACTIVE_PCR_BANKS]; - u8 vendor_info_size; - u8 vendor_info[0]; + struct tcg_efi_specid_event_algs digest_sizes[]; } __packed; struct tcg_pcr_event { @@ -113,12 +110,11 @@ struct tpm2_digest { u8 digest[SHA512_DIGEST_SIZE]; } __packed; -struct tcg_pcr_event2 { +struct tcg_pcr_event2_head { u32 pcr_idx; u32 event_type; u32 count; - struct tpm2_digest digests[TPM2_ACTIVE_PCR_BANKS]; - struct tcg_event_field event; + struct tpm2_digest digests[]; } __packed; #endif -- 2.17.1

From: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; commit aa042475938f5818b0c1b6203061e85ad2535dbc upstream. Rename tpm2_* to tpm_* and move the definitions to include/linux/tpm.h so that these can be used by other kernel subsystems (e.g. IMA). Also, set the length of the digest array in tpm_digest to a new constant named TPM_MAX_DIGEST_SIZE, equal to SHA512_DIGEST_SIZE. Signed-off-by: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; Reviewed-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Tested-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Acked-by: Mimi Zohar &lt;zohar(a)linux.ibm.com&gt; Signed-off-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; [mayuanchen: kernel 4.19.91 has tpm1_auto_startup in drivers/char/tpm/tpm-interface.c, adjust patch apply accordingly] Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: Ie81b5f889a024c2dab2794f1ebfe3752c2b2388d --- drivers/char/tpm/tpm-interface.c | 4 ++-- drivers/char/tpm/tpm.h | 13 +------------ drivers/char/tpm/tpm2-cmd.c | 18 +++++++++--------- include/linux/tpm.h | 19 +++++++++++++++++++ include/linux/tpm_eventlog.h | 9 ++------- 5 files changed, 33 insertions(+), 30 deletions(-) diff --git a/drivers/char/tpm/tpm-interface.c b/drivers/char/tpm/tpm-interface.c index 276e2a820b1c..0ad9c6099873 100644 --- a/drivers/char/tpm/tpm-interface.c +++ b/drivers/char/tpm/tpm-interface.c @@ -1050,7 +1050,7 @@ static int tpm1_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash, int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash) { int rc; - struct tpm2_digest *digest_list; + struct tpm_digest *digest_list; int i; chip = tpm_find_get_ops(chip); @@ -1173,7 +1173,7 @@ int tpm1_auto_startup(struct tpm_chip *chip) goto out; } - chip->allocated_banks[0] = TPM2_ALG_SHA1; + chip->allocated_banks[0] = TPM_ALG_SHA1; chip->nr_allocated_banks = 1; return rc; diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h index 44f93fa39d68..c3ac26f14b75 100644 --- a/drivers/char/tpm/tpm.h +++ b/drivers/char/tpm/tpm.h @@ -122,17 +122,6 @@ enum tpm2_return_codes { TPM2_RC_RETRY = 0x0922, }; -enum tpm2_algorithms { - TPM2_ALG_ERROR = 0x0000, - TPM2_ALG_SHA1 = 0x0004, - TPM2_ALG_KEYEDHASH = 0x0008, - TPM2_ALG_SHA256 = 0x000B, - TPM2_ALG_SHA384 = 0x000C, - TPM2_ALG_SHA512 = 0x000D, - TPM2_ALG_NULL = 0x0010, - TPM2_ALG_SM3_256 = 0x0012, -}; - enum tpm2_command_codes { TPM2_CC_FIRST = 0x011F, TPM2_CC_CREATE_PRIMARY = 0x0131, @@ -578,7 +567,7 @@ static inline u32 tpm2_rc_value(u32 rc) int tpm2_pcr_read(struct tpm_chip *chip, u32 pcr_idx, u8 *res_buf); int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count, - struct tpm2_digest *digests); + struct tpm_digest *digests); int tpm2_get_random(struct tpm_chip *chip, u8 *dest, size_t max); void tpm2_flush_context_cmd(struct tpm_chip *chip, u32 handle, unsigned int flags); diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c index 759c525ad21f..4c2d52dde671 100644 --- a/drivers/char/tpm/tpm2-cmd.c +++ b/drivers/char/tpm/tpm2-cmd.c @@ -33,11 +33,11 @@ struct tpm2_hash { }; static struct tpm2_hash tpm2_hash_map[] = { - {HASH_ALGO_SHA1, TPM2_ALG_SHA1}, - {HASH_ALGO_SHA256, TPM2_ALG_SHA256}, - {HASH_ALGO_SHA384, TPM2_ALG_SHA384}, - {HASH_ALGO_SHA512, TPM2_ALG_SHA512}, - {HASH_ALGO_SM3_256, TPM2_ALG_SM3_256}, + {HASH_ALGO_SHA1, TPM_ALG_SHA1}, + {HASH_ALGO_SHA256, TPM_ALG_SHA256}, + {HASH_ALGO_SHA384, TPM_ALG_SHA384}, + {HASH_ALGO_SHA512, TPM_ALG_SHA512}, + {HASH_ALGO_SM3_256, TPM_ALG_SM3_256}, }; /* @@ -200,7 +200,7 @@ int tpm2_pcr_read(struct tpm_chip *chip, u32 pcr_idx, u8 *res_buf) pcr_select[pcr_idx >> 3] = 1 << (pcr_idx & 0x7); tpm_buf_append_u32(&buf, 1); - tpm_buf_append_u16(&buf, TPM2_ALG_SHA1); + tpm_buf_append_u16(&buf, TPM_ALG_SHA1); tpm_buf_append_u8(&buf, TPM2_PCR_SELECT_MIN); tpm_buf_append(&buf, (const unsigned char *)pcr_select, sizeof(pcr_select)); @@ -234,7 +234,7 @@ struct tpm2_null_auth_area { * Return: Same as with tpm_transmit_cmd. */ int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count, - struct tpm2_digest *digests) + struct tpm_digest *digests) { struct tpm_buf buf; struct tpm2_null_auth_area auth_area; @@ -458,7 +458,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip, /* public */ tpm_buf_append_u16(&buf, 14 + options->policydigest_len); - tpm_buf_append_u16(&buf, TPM2_ALG_KEYEDHASH); + tpm_buf_append_u16(&buf, TPM_ALG_KEYEDHASH); tpm_buf_append_u16(&buf, hash); /* policy */ @@ -473,7 +473,7 @@ int tpm2_seal_trusted(struct tpm_chip *chip, } /* public parameters */ - tpm_buf_append_u16(&buf, TPM2_ALG_NULL); + tpm_buf_append_u16(&buf, TPM_ALG_NULL); tpm_buf_append_u16(&buf, 0); /* outside info */ diff --git a/include/linux/tpm.h b/include/linux/tpm.h index b49a55cf775f..d26793d82986 100644 --- a/include/linux/tpm.h +++ b/include/linux/tpm.h @@ -22,12 +22,31 @@ #ifndef __LINUX_TPM_H__ #define __LINUX_TPM_H__ +#include <crypto/hash_info.h> + #define TPM_DIGEST_SIZE 20 /* Max TPM v1.2 PCR size */ +#define TPM_MAX_DIGEST_SIZE SHA512_DIGEST_SIZE struct tpm_chip; struct trusted_key_payload; struct trusted_key_options; +enum tpm_algorithms { + TPM_ALG_ERROR = 0x0000, + TPM_ALG_SHA1 = 0x0004, + TPM_ALG_KEYEDHASH = 0x0008, + TPM_ALG_SHA256 = 0x000B, + TPM_ALG_SHA384 = 0x000C, + TPM_ALG_SHA512 = 0x000D, + TPM_ALG_NULL = 0x0010, + TPM_ALG_SM3_256 = 0x0012, +}; + +struct tpm_digest { + u16 alg_id; + u8 digest[TPM_MAX_DIGEST_SIZE]; +} __packed; + enum TPM_OPS_FLAGS { TPM_OPS_AUTO_STARTUP = BIT(0), }; diff --git a/include/linux/tpm_eventlog.h b/include/linux/tpm_eventlog.h index f47342361e87..81519f163211 100644 --- a/include/linux/tpm_eventlog.h +++ b/include/linux/tpm_eventlog.h @@ -3,7 +3,7 @@ #ifndef __LINUX_TPM_EVENTLOG_H__ #define __LINUX_TPM_EVENTLOG_H__ -#include <crypto/hash_info.h> +#include <linux/tpm.h> #define TCG_EVENT_NAME_LEN_MAX 255 #define MAX_TEXT_EVENT 1000 /* Max event string length */ @@ -105,16 +105,11 @@ struct tcg_event_field { u8 event[0]; } __packed; -struct tpm2_digest { - u16 alg_id; - u8 digest[SHA512_DIGEST_SIZE]; -} __packed; - struct tcg_pcr_event2_head { u32 pcr_idx; u32 event_type; u32 count; - struct tpm2_digest digests[]; + struct tpm_digest digests[]; } __packed; #endif -- 2.17.1

From: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; commit 901615cb916dc955fb7bda4e34402bf263532e4a upstream. The tpm_chip structure contains the list of PCR banks currently allocated in the TPM. When support for crypto agility will be added to the TPM driver, users of the driver have to provide a digest for each allocated bank to tpm_pcr_extend(). With this patch, they can obtain the PCR bank algorithms directly from chip->allocated_banks. Signed-off-by: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; Reviewed-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Tested-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Signed-off-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; [mayuanchen: remove last_cc in struct tpm_chip due to different interface] Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: Icb46c3042dfe9c293cb9c433aab9d21d63f8ca6b --- drivers/char/tpm/tpm.h | 100 ++--------------------------------------- include/linux/tpm.h | 90 +++++++++++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+), 96 deletions(-) diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h index d60a05c2bac0..3171c80e3546 100644 --- a/drivers/char/tpm/tpm.h +++ b/drivers/char/tpm/tpm.h @@ -25,30 +25,22 @@ #include <linux/module.h> #include <linux/delay.h> -#include <linux/fs.h> -#include <linux/hw_random.h> #include <linux/mutex.h> #include <linux/sched.h> #include <linux/platform_device.h> #include <linux/io.h> #include <linux/tpm.h> -#include <linux/acpi.h> -#include <linux/cdev.h> #include <linux/highmem.h> #include <linux/tpm_eventlog.h> -#include <crypto/hash_info.h> #ifdef CONFIG_X86 #include <asm/intel-family.h> #endif -enum tpm_const { - TPM_MINOR = 224, /* officially assigned */ - TPM_BUFSIZE = 4096, - TPM_NUM_DEVICES = 65536, - TPM_RETRY = 50, /* 5 seconds */ - TPM_NUM_EVENT_LOG_FILES = 3, -}; +#define TPM_MINOR 224 /* officially assigned */ +#define TPM_BUFSIZE 4096 +#define TPM_NUM_DEVICES 65536 +#define TPM_RETRY 50 enum tpm_timeout { TPM_TIMEOUT = 5, /* msecs */ @@ -65,16 +57,6 @@ enum tpm_addr { TPM_ADDR = 0x4E, }; -/* Indexes the duration array */ -enum tpm_duration { - TPM_SHORT = 0, - TPM_MEDIUM = 1, - TPM_LONG = 2, - TPM_LONG_LONG = 3, - TPM_UNDEFINED, - TPM_NUM_DURATIONS = TPM_UNDEFINED, -}; - #define TPM_WARN_RETRY 0x800 #define TPM_WARN_DOING_SELFTEST 0x802 #define TPM_ERR_DEACTIVATED 0x6 @@ -170,15 +152,6 @@ enum tpm2_cc_attrs { #define TPM_VID_WINBOND 0x1050 #define TPM_VID_STM 0x104A -#define TPM_PPI_VERSION_LEN 3 - -struct tpm_space { - u32 context_tbl[3]; - u8 *context_buf; - u32 session_tbl[3]; - u8 *session_buf; -}; - enum tpm_chip_flags { TPM_CHIP_FLAG_TPM2 = BIT(1), TPM_CHIP_FLAG_IRQ = BIT(2), @@ -187,71 +160,6 @@ enum tpm_chip_flags { TPM_CHIP_FLAG_ALWAYS_POWERED = BIT(5), }; -struct tpm_bios_log { - void *bios_event_log; - void *bios_event_log_end; -}; - -struct tpm_chip_seqops { - struct tpm_chip *chip; - const struct seq_operations *seqops; -}; - -struct tpm_chip { - struct device dev; - struct device devs; - struct cdev cdev; - struct cdev cdevs; - - /* A driver callback under ops cannot be run unless ops_sem is held - * (sometimes implicitly, eg for the sysfs code). ops becomes null - * when the driver is unregistered, see tpm_try_get_ops. - */ - struct rw_semaphore ops_sem; - const struct tpm_class_ops *ops; - - struct tpm_bios_log log; - struct tpm_chip_seqops bin_log_seqops; - struct tpm_chip_seqops ascii_log_seqops; - - unsigned int flags; - - int dev_num; /* /dev/tpm# */ - unsigned long is_open; /* only one allowed */ - - char hwrng_name[64]; - struct hwrng hwrng; - - struct mutex tpm_mutex; /* tpm is processing */ - - unsigned long timeout_a; /* jiffies */ - unsigned long timeout_b; /* jiffies */ - unsigned long timeout_c; /* jiffies */ - unsigned long timeout_d; /* jiffies */ - bool timeout_adjusted; - unsigned long duration[TPM_NUM_DURATIONS]; /* jiffies */ - bool duration_adjusted; - - struct dentry *bios_dir[TPM_NUM_EVENT_LOG_FILES]; - - const struct attribute_group *groups[3]; - unsigned int groups_cnt; - - u32 nr_allocated_banks; - struct tpm_bank_info *allocated_banks; -#ifdef CONFIG_ACPI - acpi_handle acpi_dev_handle; - char ppi_version[TPM_PPI_VERSION_LEN + 1]; -#endif /* CONFIG_ACPI */ - - struct tpm_space work_space; - u32 nr_commands; - u32 *cc_attrs_tbl; - - /* active locality */ - int locality; -}; - #define to_tpm_chip(d) container_of(d, struct tpm_chip, dev) struct tpm_input_header { diff --git a/include/linux/tpm.h b/include/linux/tpm.h index 8681772cd1e5..920e7a455636 100644 --- a/include/linux/tpm.h +++ b/include/linux/tpm.h @@ -22,6 +22,10 @@ #ifndef __LINUX_TPM_H__ #define __LINUX_TPM_H__ +#include <linux/hw_random.h> +#include <linux/acpi.h> +#include <linux/cdev.h> +#include <linux/fs.h> #include <crypto/hash_info.h> #define TPM_DIGEST_SIZE 20 /* Max TPM v1.2 PCR size */ @@ -75,6 +79,92 @@ struct tpm_class_ops { void (*clk_enable)(struct tpm_chip *chip, bool value); }; +#define TPM_NUM_EVENT_LOG_FILES 3 + +/* Indexes the duration array */ +enum tpm_duration { + TPM_SHORT = 0, + TPM_MEDIUM = 1, + TPM_LONG = 2, + TPM_LONG_LONG = 3, + TPM_UNDEFINED, + TPM_NUM_DURATIONS = TPM_UNDEFINED, +}; + +#define TPM_PPI_VERSION_LEN 3 + +struct tpm_space { + u32 context_tbl[3]; + u8 *context_buf; + u32 session_tbl[3]; + u8 *session_buf; +}; + +struct tpm_bios_log { + void *bios_event_log; + void *bios_event_log_end; +}; + +struct tpm_chip_seqops { + struct tpm_chip *chip; + const struct seq_operations *seqops; +}; + +struct tpm_chip { + struct device dev; + struct device devs; + struct cdev cdev; + struct cdev cdevs; + + /* A driver callback under ops cannot be run unless ops_sem is held + * (sometimes implicitly, eg for the sysfs code). ops becomes null + * when the driver is unregistered, see tpm_try_get_ops. + */ + struct rw_semaphore ops_sem; + const struct tpm_class_ops *ops; + + struct tpm_bios_log log; + struct tpm_chip_seqops bin_log_seqops; + struct tpm_chip_seqops ascii_log_seqops; + + unsigned int flags; + + int dev_num; /* /dev/tpm# */ + unsigned long is_open; /* only one allowed */ + + char hwrng_name[64]; + struct hwrng hwrng; + + struct mutex tpm_mutex; /* tpm is processing */ + + unsigned long timeout_a; /* jiffies */ + unsigned long timeout_b; /* jiffies */ + unsigned long timeout_c; /* jiffies */ + unsigned long timeout_d; /* jiffies */ + bool timeout_adjusted; + unsigned long duration[TPM_NUM_DURATIONS]; /* jiffies */ + bool duration_adjusted; + + struct dentry *bios_dir[TPM_NUM_EVENT_LOG_FILES]; + + const struct attribute_group *groups[3]; + unsigned int groups_cnt; + + u32 nr_allocated_banks; + struct tpm_bank_info *allocated_banks; +#ifdef CONFIG_ACPI + acpi_handle acpi_dev_handle; + char ppi_version[TPM_PPI_VERSION_LEN + 1]; +#endif /* CONFIG_ACPI */ + + struct tpm_space work_space; + u32 nr_commands; + u32 *cc_attrs_tbl; + + /* active locality */ + int locality; +}; + #if defined(CONFIG_TCG_TPM) || defined(CONFIG_TCG_TPM_MODULE) extern int tpm_is_tpm2(struct tpm_chip *chip); -- 2.17.1

From: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; commit 0b6cf6b97b7ef1fa3c7fefab0cac897a1c4a3400 upstream. Currently, tpm_pcr_extend() accepts as an input only a SHA1 digest. This patch replaces the hash parameter of tpm_pcr_extend() with an array of tpm_digest structures, so that the caller can provide a digest for each PCR bank currently allocated in the TPM. tpm_pcr_extend() will not extend banks for which no digest was provided, as it happened before this patch, but instead it requires that callers provide the full set of digests. Since the number of digests will always be chip->nr_allocated_banks, the count parameter has been removed. Due to the API change, ima_pcr_extend() and pcrlock() have been modified. Since the number of allocated banks is not known in advance, the memory for the digests must be dynamically allocated. To avoid performance degradation and to avoid that a PCR extend is not done due to lack of memory, the array of tpm_digest structures is allocated by the users of the TPM driver at initialization time. Signed-off-by: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; Reviewed-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Tested-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Tested-by: Mimi Zohar &lt;zohar(a)linux.ibm.com&gt; (on x86 for TPM 1.2 & PTT TPM 2.0) Signed-off-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: I38e8dd24de046778c3f0313d497b3f507139dbd7 --- drivers/char/tpm/tpm-interface.c | 30 ++++++++-------------- drivers/char/tpm/tpm.h | 2 +- drivers/char/tpm/tpm2-cmd.c | 10 +++----- include/linux/tpm.h | 5 ++-- security/integrity/ima/ima.h | 1 + security/integrity/ima/ima_init.c | 4 +++ security/integrity/ima/ima_queue.c | 27 +++++++++++++++++++- security/keys/trusted.c | 41 ++++++++++++++++++++++++------ 8 files changed, 82 insertions(+), 38 deletions(-) diff --git a/drivers/char/tpm/tpm-interface.c b/drivers/char/tpm/tpm-interface.c index 2b052c9f1f2d..b5df4dd1aa57 100644 --- a/drivers/char/tpm/tpm-interface.c +++ b/drivers/char/tpm/tpm-interface.c @@ -1040,42 +1040,34 @@ static int tpm1_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash, * tpm_pcr_extend - extend a PCR value in SHA1 bank. * @chip: a &struct tpm_chip instance, %NULL for the default chip * @pcr_idx: the PCR to be retrieved - * @hash: the hash value used to extend the PCR value + * @digests: array of tpm_digest structures used to extend PCRs * - * Note: with TPM 2.0 extends also those banks for which no digest was - * specified in order to prevent malicious use of those PCR banks. + * Note: callers must pass a digest for every allocated PCR bank, in the same + * order of the banks in chip->allocated_banks. * * Return: same as with tpm_transmit_cmd() */ -int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash) +int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, + struct tpm_digest *digests) { int rc; - struct tpm_digest *digest_list; int i; chip = tpm_find_get_ops(chip); if (!chip) return -ENODEV; - if (chip->flags & TPM_CHIP_FLAG_TPM2) { - digest_list = kcalloc(chip->nr_allocated_banks, - sizeof(*digest_list), GFP_KERNEL); - if (!digest_list) - return -ENOMEM; - - for (i = 0; i < chip->nr_allocated_banks; i++) { - digest_list[i].alg_id = chip->allocated_banks[i].alg_id; - memcpy(digest_list[i].digest, hash, TPM_DIGEST_SIZE); - } + for (i = 0; i < chip->nr_allocated_banks; i++) + if (digests[i].alg_id != chip->allocated_banks[i].alg_id) + return -EINVAL; - rc = tpm2_pcr_extend(chip, pcr_idx, chip->nr_allocated_banks, - digest_list); - kfree(digest_list); + if (chip->flags & TPM_CHIP_FLAG_TPM2) { + rc = tpm2_pcr_extend(chip, pcr_idx, digests); tpm_put_ops(chip); return rc; } - rc = tpm1_pcr_extend(chip, pcr_idx, hash, + rc = tpm1_pcr_extend(chip, pcr_idx, digests[0].digest, "attempting extend a PCR value"); tpm_put_ops(chip); return rc; diff --git a/drivers/char/tpm/tpm.h b/drivers/char/tpm/tpm.h index 3171c80e3546..a690beaddff9 100644 --- a/drivers/char/tpm/tpm.h +++ b/drivers/char/tpm/tpm.h @@ -475,7 +475,7 @@ static inline u32 tpm2_rc_value(u32 rc) int tpm2_pcr_read(struct tpm_chip *chip, u32 pcr_idx, struct tpm_digest *digest, u16 *digest_size_ptr); -int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count, +int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, struct tpm_digest *digests); int tpm2_get_random(struct tpm_chip *chip, u8 *dest, size_t max); void tpm2_flush_context_cmd(struct tpm_chip *chip, u32 handle, diff --git a/drivers/char/tpm/tpm2-cmd.c b/drivers/char/tpm/tpm2-cmd.c index c29714bc31e2..154504daa834 100644 --- a/drivers/char/tpm/tpm2-cmd.c +++ b/drivers/char/tpm/tpm2-cmd.c @@ -256,12 +256,11 @@ struct tpm2_null_auth_area { * * @chip: TPM chip to use. * @pcr_idx: index of the PCR. - * @count: number of digests passed. * @digests: list of pcr banks and corresponding digest values to extend. * * Return: Same as with tpm_transmit_cmd. */ -int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count, +int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, struct tpm_digest *digests) { struct tpm_buf buf; @@ -269,9 +268,6 @@ int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count, int rc; int i; - if (count > chip->nr_allocated_banks) - return -EINVAL; - rc = tpm_buf_init(&buf, TPM2_ST_SESSIONS, TPM2_CC_PCR_EXTEND); if (rc) return rc; @@ -286,9 +282,9 @@ int tpm2_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, u32 count, tpm_buf_append_u32(&buf, sizeof(struct tpm2_null_auth_area)); tpm_buf_append(&buf, (const unsigned char *)&auth_area, sizeof(auth_area)); - tpm_buf_append_u32(&buf, count); + tpm_buf_append_u32(&buf, chip->nr_allocated_banks); - for (i = 0; i < count; i++) { + for (i = 0; i < chip->nr_allocated_banks; i++) { tpm_buf_append_u16(&buf, digests[i].alg_id); tpm_buf_append(&buf, (const unsigned char *)&digests[i].digest, chip->allocated_banks[i].digest_size); diff --git a/include/linux/tpm.h b/include/linux/tpm.h index 920e7a455636..c94a8e7d1704 100644 --- a/include/linux/tpm.h +++ b/include/linux/tpm.h @@ -170,7 +170,8 @@ struct tpm_chip { extern int tpm_is_tpm2(struct tpm_chip *chip); extern int tpm_pcr_read(struct tpm_chip *chip, u32 pcr_idx, struct tpm_digest *digest); -extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, const u8 *hash); +extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, + struct tpm_digest *digests); extern int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen); extern int tpm_get_random(struct tpm_chip *chip, u8 *data, size_t max); extern int tpm_seal_trusted(struct tpm_chip *chip, @@ -193,7 +194,7 @@ static inline int tpm_pcr_read(struct tpm_chip *chip, u32 pcr_idx, } static inline int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, - const u8 *hash) + struct tpm_digest *digests) { return -ENODEV; } diff --git a/security/integrity/ima/ima.h b/security/integrity/ima/ima.h index 67db9d9454ca..4e211d85f32e 100644 --- a/security/integrity/ima/ima.h +++ b/security/integrity/ima/ima.h @@ -153,6 +153,7 @@ int ima_measurements_show(struct seq_file *m, void *v); unsigned long ima_get_binary_runtime_size(void); int ima_init_template(void); void ima_init_template_list(void); +int __init ima_init_digests(void); /* * used to protect h_table and sha_table diff --git a/security/integrity/ima/ima_init.c b/security/integrity/ima/ima_init.c index faac9ecaa0ae..a9508ef781a7 100644 --- a/security/integrity/ima/ima_init.c +++ b/security/integrity/ima/ima_init.c @@ -123,8 +123,12 @@ int __init ima_init(void) if (rc != 0) return rc; + /* It can be called before ima_init_digests(), it does not use TPM. */ ima_load_kexec_buffer(); + rc = ima_init_digests(); + if (rc != 0) + return rc; rc = ima_add_boot_aggregate(); /* boot aggregate must be first entry */ if (rc != 0) return rc; diff --git a/security/integrity/ima/ima_queue.c b/security/integrity/ima/ima_queue.c index b186819bd5aa..b4ee95bad1da 100644 --- a/security/integrity/ima/ima_queue.c +++ b/security/integrity/ima/ima_queue.c @@ -28,6 +28,9 @@ #define AUDIT_CAUSE_LEN_MAX 32 +/* pre-allocated array of tpm_digest structures to extend a PCR */ +static struct tpm_digest *digests; + LIST_HEAD(ima_measurements); /* list of all measurements */ #ifdef CONFIG_IMA_KEXEC static unsigned long binary_runtime_size; @@ -141,11 +144,15 @@ unsigned long ima_get_binary_runtime_size(void) static int ima_pcr_extend(const u8 *hash, int pcr) { int result = 0; + int i; if (!ima_tpm_chip) return result; - result = tpm_pcr_extend(ima_tpm_chip, pcr, hash); + for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++) + memcpy(digests[i].digest, hash, TPM_DIGEST_SIZE); + + result = tpm_pcr_extend(ima_tpm_chip, pcr, digests); if (result != 0) pr_err("Error Communicating to TPM chip, result: %d\n", result); return result; @@ -212,3 +219,21 @@ int ima_restore_measurement_entry(struct ima_template_entry *entry) mutex_unlock(&ima_extend_list_mutex); return result; } + +int __init ima_init_digests(void) +{ + int i; + + if (!ima_tpm_chip) + return 0; + + digests = kcalloc(ima_tpm_chip->nr_allocated_banks, sizeof(*digests), + GFP_NOFS); + if (!digests) + return -ENOMEM; + + for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++) + digests[i].alg_id = ima_tpm_chip->allocated_banks[i].alg_id; + + return 0; +} diff --git a/security/keys/trusted.c b/security/keys/trusted.c index a08a41deda81..fb934887b2d2 100644 --- a/security/keys/trusted.c +++ b/security/keys/trusted.c @@ -35,6 +35,7 @@ static const char hmac_alg[] = "hmac(sha1)"; static const char hash_alg[] = "sha1"; static struct tpm_chip *chip; +static struct tpm_digest *digests; struct sdesc { struct shash_desc shash; @@ -377,15 +378,10 @@ static int trusted_tpm_send(unsigned char *cmd, size_t buflen) */ static int pcrlock(const int pcrnum) { - unsigned char hash[SHA1_DIGEST_SIZE]; - int ret; - if (!capable(CAP_SYS_ADMIN)) return -EPERM; - ret = tpm_get_random(chip, hash, SHA1_DIGEST_SIZE); - if (ret != SHA1_DIGEST_SIZE) - return ret; - return tpm_pcr_extend(chip, pcrnum, hash) ? -EINVAL : 0; + + return tpm_pcr_extend(chip, pcrnum, digests) ? -EINVAL : 0; } /* @@ -1218,6 +1214,29 @@ static int __init trusted_shash_alloc(void) return ret; } +static int __init init_digests(void) +{ + u8 digest[TPM_MAX_DIGEST_SIZE]; + int ret; + int i; + + ret = tpm_get_random(chip, digest, TPM_MAX_DIGEST_SIZE); + if (ret < 0) + return ret; + if (ret < TPM_MAX_DIGEST_SIZE) + return -EFAULT; + + digests = kcalloc(chip->nr_allocated_banks, sizeof(*digests), + GFP_KERNEL); + if (!digests) + return -ENOMEM; + + for (i = 0; i < chip->nr_allocated_banks; i++) + memcpy(digests[i].digest, digest, TPM_MAX_DIGEST_SIZE); + + return 0; +} + static int __init init_trusted(void) { int ret; @@ -1225,15 +1244,20 @@ static int __init init_trusted(void) chip = tpm_default_chip(); if (!chip) return -ENOENT; - ret = trusted_shash_alloc(); + ret = init_digests(); if (ret < 0) goto err_put; + ret = trusted_shash_alloc(); + if (ret < 0) + goto err_free; ret = register_key_type(&key_type_trusted); if (ret < 0) goto err_release; return 0; err_release: trusted_shash_release(); +err_free: + kfree(digests); err_put: put_device(&chip->dev); return ret; @@ -1242,6 +1266,7 @@ static int __init init_trusted(void) static void __exit cleanup_trusted(void) { put_device(&chip->dev); + kfree(digests); trusted_shash_release(); unregister_key_type(&key_type_trusted); } -- 2.17.1

From: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; commit 9f75c82246313d4c2a6bc77e947b45655b3b5ad5 upstream. Commit 0b6cf6b97b7e ("tpm: pass an array of tpm_extend_digest structures to tpm_pcr_extend()") modifies tpm_pcr_extend() to accept a digest for each PCR bank. After modification, tpm_pcr_extend() expects that digests are passed in the same order as the algorithms set in chip->allocated_banks. This patch fixes two issues introduced in the last iterations of the patch set: missing initialization of the TPM algorithm ID in the tpm_digest structures passed to tpm_pcr_extend() by the trusted key module, and unreleased locks in the TPM driver due to returning from tpm_pcr_extend() without calling tpm_put_ops(). Cc: stable(a)vger.kernel.org Fixes: 0b6cf6b97b7e ("tpm: pass an array of tpm_extend_digest structures to tpm_pcr_extend()") Signed-off-by: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; Suggested-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Reviewed-by: Jerry Snitselaar &lt;jsnitsel(a)redhat.com&gt; Reviewed-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Signed-off-by: Jarkko Sakkinen &lt;jarkko.sakkinen(a)linux.intel.com&gt; Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: I4a6203e18fff9a3bce67083eb4bea63df92eee24 --- drivers/char/tpm/tpm-interface.c | 14 +++++++++----- security/keys/trusted.c | 5 +++++ 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/drivers/char/tpm/tpm-interface.c b/drivers/char/tpm/tpm-interface.c index b5df4dd1aa57..74362e287d59 100644 --- a/drivers/char/tpm/tpm-interface.c +++ b/drivers/char/tpm/tpm-interface.c @@ -1057,18 +1057,22 @@ int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, if (!chip) return -ENODEV; - for (i = 0; i < chip->nr_allocated_banks; i++) - if (digests[i].alg_id != chip->allocated_banks[i].alg_id) - return -EINVAL; + for (i = 0; i < chip->nr_allocated_banks; i++) { + if (digests[i].alg_id != chip->allocated_banks[i].alg_id) { + rc = EINVAL; + goto out; + } + } if (chip->flags & TPM_CHIP_FLAG_TPM2) { rc = tpm2_pcr_extend(chip, pcr_idx, digests); - tpm_put_ops(chip); - return rc; + goto out; } rc = tpm1_pcr_extend(chip, pcr_idx, digests[0].digest, "attempting extend a PCR value"); + +out: tpm_put_ops(chip); return rc; } diff --git a/security/keys/trusted.c b/security/keys/trusted.c index 4b43ff25bdc4..d37498185d47 100644 --- a/security/keys/trusted.c +++ b/security/keys/trusted.c @@ -1216,11 +1216,16 @@ static int __init trusted_shash_alloc(void) static int __init init_digests(void) { + int i; + digests = kcalloc(chip->nr_allocated_banks, sizeof(*digests), GFP_KERNEL); if (!digests) return -ENOMEM; + for (i = 0; i < chip->nr_allocated_banks; i++) + digests[i].alg_id = chip->allocated_banks[i].alg_id; + return 0; } -- 2.17.1

From: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; commit 6f1a1d103b48b1533a9c804e7a069e2c8e937ce7 upstream. boot_aggregate is the first entry of IMA measurement list. Its purpose is to link pre-boot measurements to IMA measurements. As IMA was designed to work with a TPM 1.2, the SHA1 PCR bank was always selected even if a TPM 2.0 with support for stronger hash algorithms is available. This patch first tries to find a PCR bank with the IMA default hash algorithm. If it does not find it, it selects the SHA256 PCR bank for TPM 2.0 and SHA1 for TPM 1.2. Ultimately, it selects SHA1 also for TPM 2.0 if the SHA256 PCR bank is not found. If none of the PCR banks above can be found, boot_aggregate file digest is filled with zeros, as for TPM bypass, making it impossible to perform a remote attestation of the system. Cc: stable(a)vger.kernel.org # 5.1.x Fixes: 879b589210a9 ("tpm: retrieve digest size of unknown algorithms with PCR read") Reported-by: Jerry Snitselaar &lt;jsnitsel(a)redhat.com&gt; Suggested-by: James Bottomley &lt;James.Bottomley(a)HansenPartnership.com&gt; Signed-off-by: Roberto Sassu &lt;roberto.sassu(a)huawei.com&gt; Signed-off-by: Mimi Zohar &lt;zohar(a)linux.ibm.com&gt; Signed-off-by: mayuanchen &lt;mayuanchen(a)hygon.cn&gt; Change-Id: I0177200f2abeb3f0924a268a6f89fd836b0216d7 --- security/integrity/ima/ima_crypto.c | 47 +++++++++++++++++++++++++---- security/integrity/ima/ima_init.c | 22 +++++++++++--- 2 files changed, 58 insertions(+), 11 deletions(-) diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c index 8fac7172b66d..cf2a344f91de 100644 --- a/security/integrity/ima/ima_crypto.c +++ b/security/integrity/ima/ima_crypto.c @@ -661,12 +661,20 @@ static void __init ima_pcrread(u32 idx, struct tpm_digest *d) } /* - * Calculate the boot aggregate hash + * The boot_aggregate is a cumulative hash over TPM registers 0 - 7. With + * TPM 1.2 the boot_aggregate was based on reading the SHA1 PCRs, but with + * TPM 2.0 hash agility, TPM chips could support multiple TPM PCR banks, + * allowing firmware to configure and enable different banks. + * + * Knowing which TPM bank is read to calculate the boot_aggregate digest + * needs to be conveyed to a verifier. For this reason, use the same + * hash algorithm for reading the TPM PCRs as for calculating the boot + * aggregate digest as stored in the measurement list. */ -static int __init ima_calc_boot_aggregate_tfm(char *digest, +static int __init ima_calc_boot_aggregate_tfm(char *digest, u16 alg_id, struct crypto_shash *tfm) { - struct tpm_digest d = { .alg_id = TPM_ALG_SHA1, .digest = {0} }; + struct tpm_digest d = { .alg_id = alg_id, .digest = {0} }; int rc; u32 i; SHASH_DESC_ON_STACK(shash, tfm); @@ -674,6 +682,9 @@ static int __init ima_calc_boot_aggregate_tfm(char *digest, shash->tfm = tfm; shash->flags = 0; + pr_devel("calculating the boot-aggregate based on TPM bank: %04x\n", + d.alg_id); + rc = crypto_shash_init(shash); if (rc != 0) return rc; @@ -682,7 +693,8 @@ static int __init ima_calc_boot_aggregate_tfm(char *digest, for (i = TPM_PCR0; i < TPM_PCR8; i++) { ima_pcrread(i, &d); /* now accumulate with current aggregate */ - rc = crypto_shash_update(shash, d.digest, TPM_DIGEST_SIZE); + rc = crypto_shash_update(shash, d.digest, + crypto_shash_digestsize(tfm)); } if (!rc) crypto_shash_final(shash, digest); @@ -692,14 +704,37 @@ static int __init ima_calc_boot_aggregate_tfm(char *digest, int __init ima_calc_boot_aggregate(struct ima_digest_data *hash) { struct crypto_shash *tfm; - int rc; + u16 crypto_id, alg_id; + int rc, i, bank_idx = -1; + + for (i = 0; i < ima_tpm_chip->nr_allocated_banks; i++) { + crypto_id = ima_tpm_chip->allocated_banks[i].crypto_id; + if (crypto_id == hash->algo) { + bank_idx = i; + break; + } + + if (crypto_id == HASH_ALGO_SHA256) + bank_idx = i; + + if (bank_idx == -1 && crypto_id == HASH_ALGO_SHA1) + bank_idx = i; + } + + if (bank_idx == -1) { + pr_err("No suitable TPM algorithm for boot aggregate\n"); + return 0; + } + + hash->algo = ima_tpm_chip->allocated_banks[bank_idx].crypto_id; tfm = ima_alloc_tfm(hash->algo); if (IS_ERR(tfm)) return PTR_ERR(tfm); hash->length = crypto_shash_digestsize(tfm); - rc = ima_calc_boot_aggregate_tfm(hash->digest, tfm); + alg_id = ima_tpm_chip->allocated_banks[bank_idx].alg_id; + rc = ima_calc_boot_aggregate_tfm(hash->digest, alg_id, tfm); ima_free_tfm(tfm); diff --git a/security/integrity/ima/ima_init.c b/security/integrity/ima/ima_init.c index a9508ef781a7..29207e526ea8 100644 --- a/security/integrity/ima/ima_init.c +++ b/security/integrity/ima/ima_init.c @@ -31,7 +31,7 @@ struct tpm_chip *ima_tpm_chip; /* Add the boot aggregate to the IMA measurement list and extend * the PCR register. * - * Calculate the boot aggregate, a SHA1 over tpm registers 0-7, + * Calculate the boot aggregate, a hash over tpm registers 0-7, * assuming a TPM chip exists, and zeroes if the TPM chip does not * exist. Add the boot aggregate measurement to the measurement * list and extend the PCR register. @@ -55,15 +55,27 @@ static int __init ima_add_boot_aggregate(void) int violation = 0; struct { struct ima_digest_data hdr; - char digest[TPM_DIGEST_SIZE]; + char digest[TPM_MAX_DIGEST_SIZE]; } hash; memset(iint, 0, sizeof(*iint)); memset(&hash, 0, sizeof(hash)); iint->ima_hash = &hash.hdr; - iint->ima_hash->algo = HASH_ALGO_SHA1; - iint->ima_hash->length = SHA1_DIGEST_SIZE; - + iint->ima_hash->algo = ima_hash_algo; + iint->ima_hash->length = hash_digest_size[ima_hash_algo]; + + /* + * With TPM 2.0 hash agility, TPM chips could support multiple TPM + * PCR banks, allowing firmware to configure and enable different + * banks. The SHA1 bank is not necessarily enabled. + * + * Use the same hash algorithm for reading the TPM PCRs as for + * calculating the boot aggregate digest. Preference is given to + * the configured IMA default hash algorithm. Otherwise, use the + * TCG required banks - SHA256 for TPM 2.0, SHA1 for TPM 1.2. + * Ultimately select SHA1 also for TPM 2.0 if the SHA256 PCR bank + * is not found. + */ if (ima_tpm_chip) { result = ima_calc_boot_aggregate(&hash.hdr); if (result < 0) { -- 2.17.1