From 536bc754e2c706441e8b970aa7b490efb72012ec Mon Sep 17 00:00:00 2001 From: Mingyen Hung Date: Fri, 30 Jun 2023 00:07:21 -0700 Subject: [PATCH] FBE: add aml_trusted_key for kernel 5.15 [1/1] PD#SWPL-130061 Problem: Need to poring FBE from kernel 5.4 to 5.15 Solution: 1. Poring FBE from kernel 5.4 to 5.15 2. Use allocate shm as a workaround, since register shm sometimes fails. Verify: 1. SC2 + ah212 + RDK kernel 5.15 Change-Id: I69b2723bafca0cbe8cc9e26010a20dc33860fc54 Signed-off-by: Mingyen Hung --- drivers/Kconfig | 1 + drivers/Makefile | 1 + drivers/aml_trusted_keys/Kconfig | 35 ++ drivers/aml_trusted_keys/Makefile | 16 + drivers/aml_trusted_keys/trusted_core.c | 402 ++++++++++++++++++++++ drivers/aml_trusted_keys/trusted_tee.c | 432 ++++++++++++++++++++++++ 6 files changed, 887 insertions(+) create mode 100644 drivers/aml_trusted_keys/Kconfig create mode 100644 drivers/aml_trusted_keys/Makefile create mode 100644 drivers/aml_trusted_keys/trusted_core.c create mode 100644 drivers/aml_trusted_keys/trusted_tee.c diff --git a/drivers/Kconfig b/drivers/Kconfig index 260ddb863..bca772bd0 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -59,4 +59,5 @@ source "$(COMMON_DRIVERS_DIR)/drivers/algorithm/Kconfig" source "$(COMMON_DRIVERS_DIR)/drivers/firmware/Kconfig" source "$(COMMON_DRIVERS_DIR)/drivers/timestamp/Kconfig" source "$(COMMON_DRIVERS_DIR)/drivers/seckey/Kconfig" +source "$(COMMON_DRIVERS_DIR)/drivers/aml_trusted_keys/Kconfig" endmenu diff --git a/drivers/Makefile b/drivers/Makefile index 147605348..833b657dc 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -20,6 +20,7 @@ obj-$(CONFIG_SPI) += spi/ obj-y += char/ obj-$(CONFIG_AMLOGIC_TEE) += tee/ obj-$(CONFIG_AML_TEE) += aml_tee/ +obj-$(CONFIG_AMLOGIC_TRUSTED_KEYS) += aml_trusted_keys/ obj-$(CONFIG_AMLOGIC_GX_SUSPEND) += pm/ obj-$(CONFIG_INPUT) += input/ obj-$(CONFIG_WATCHDOG) += watchdog/ diff --git a/drivers/aml_trusted_keys/Kconfig b/drivers/aml_trusted_keys/Kconfig new file mode 100644 index 000000000..6ce4c7793 --- /dev/null +++ b/drivers/aml_trusted_keys/Kconfig @@ -0,0 +1,35 @@ + +config AMLOGIC_LINUX_FBE + bool "Amlogic's FBE implementation" + default n + depends on AMLOGIC_TRUSTED_KEYS && AMLOGIC_TRUSTED_KEYS_TEE + help + This option is for enabling Amlogic's FBE feature. Currently, + it only works on trusted-key with tee backend. + +config AMLOGIC_LINUX_FBE_RDK + bool "Customization of Amlogic's FBE for RDK" + depends on AMLOGIC_LINUX_FBE + default n + help + This option is for enabling customization of Amlogic's FBE for RDK + +config AMLOGIC_TRUSTED_KEYS + tristate "AMLOGIC TRUSTED_KEYS" + depends on KEYS + default n + help + This option provides support for creating, sealing, and unsealing + keys in the kernel. Trusted keys are random number symmetric keys, + generated and sealed by a trust source selected at kernel boot-time. + Userspace will only ever see encrypted blobs. + + If you are unsure as to whether this is required, answer N. + +config AMLOGIC_TRUSTED_KEYS_TEE + tristate "Amlogic TEE-based trusted keys" + depends on AML_TEE >= AMLOGIC_TRUSTED_KEYS + default n + help + Enable use of the Trusted Execution Environment (TEE) as trusted + key backend. diff --git a/drivers/aml_trusted_keys/Makefile b/drivers/aml_trusted_keys/Makefile new file mode 100644 index 000000000..a03ac7a7a --- /dev/null +++ b/drivers/aml_trusted_keys/Makefile @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: (GPL-2.0+ OR MIT) + +MODULE_NAME = amlogic-trusted-keys +obj-$(CONFIG_AMLOGIC_TRUSTED_KEYS) = $(MODULE_NAME).o +$(MODULE_NAME)-y += trusted_core.o +$(MODULE_NAME)-$(CONFIG_AMLOGIC_TRUSTED_KEYS_TEE) += trusted_tee.o + +PR_FMT = $(subst amlogic-,,$(MODULE_NAME)) +PR_FMT_DEFINE="-Dpr_fmt(fmt)= \"[$(PR_FMT)]: \" fmt" +ccflags-y += $(PR_FMT_DEFINE) +BUILD_TIME := $(shell date +%Y.%m.%d-%H.%M.%S) +ccflags-y += "-DBUILD_TIME=\"$(BUILD_TIME)\"" + +COMMON_DRIVER_RELEASE=$(subst -g,, $(shell $(srctree)/scripts/setlocalversion $(srctree)/$(COMMON_DRIVERS_DIR))) +COMMON_DRIVER_RELEASE_DEFINE="-DCOMMON_DRIVER_RELEASE=\"$(COMMON_DRIVER_RELEASE)\"" +ccflags-y += $(COMMON_DRIVER_RELEASE_DEFINE) diff --git a/drivers/aml_trusted_keys/trusted_core.c b/drivers/aml_trusted_keys/trusted_core.c new file mode 100644 index 000000000..f24a908b2 --- /dev/null +++ b/drivers/aml_trusted_keys/trusted_core.c @@ -0,0 +1,402 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2010 IBM Corporation + * Copyright (c) 2019-2021, Linaro Limited + * + * See Documentation/security/keys/trusted-encrypted.rst + */ + +#include +#include +#if IS_REACHABLE(CONFIG_AMLOGIC_TRUSTED_KEYS_TEE) +#include +#endif +#if IS_REACHABLE(CONFIG_TRUSTED_KEYS_CAAM) +#include +#endif +#if IS_REACHABLE(CONFIG_TRUSTED_KEYS_TPM) +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static char *trusted_rng = "default"; +module_param_named(rng, trusted_rng, charp, 0); +MODULE_PARM_DESC(rng, "Select trusted key RNG"); + +static char *trusted_key_source; +module_param_named(source, trusted_key_source, charp, 0); +MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee or caam)"); + +static const struct trusted_key_source trusted_key_sources[] = { +#if IS_REACHABLE(CONFIG_AMLOGIC_TRUSTED_KEYS_TEE) + { "tee", &trusted_key_tee_ops }, +#endif +}; + +DEFINE_STATIC_CALL_NULL(trusted_key_init, *trusted_key_sources[0].ops->init); +DEFINE_STATIC_CALL_NULL(trusted_key_seal, *trusted_key_sources[0].ops->seal); +DEFINE_STATIC_CALL_NULL(trusted_key_unseal, + *trusted_key_sources[0].ops->unseal); +DEFINE_STATIC_CALL_NULL(trusted_key_get_random, + *trusted_key_sources[0].ops->get_random); +DEFINE_STATIC_CALL_NULL(trusted_key_exit, *trusted_key_sources[0].ops->exit); +static unsigned char migratable; + +enum { + Opt_err, + Opt_new, + Opt_load, + Opt_update, +}; + +static const match_table_t key_tokens = { + {Opt_new, "new"}, + {Opt_load, "load"}, + {Opt_update, "update"}, + {Opt_err, NULL} +}; + +/* + * datablob_parse - parse the keyctl data and fill in the + * payload structure + * + * On success returns 0, otherwise -EINVAL. + */ +static int datablob_parse(char **datablob, struct trusted_key_payload *p) +{ + substring_t args[MAX_OPT_ARGS]; + long keylen; + int ret = -EINVAL; + int key_cmd; + char *c; + + /* main command */ + c = strsep(datablob, " \t"); + if (!c) + return -EINVAL; + key_cmd = match_token(c, key_tokens, args); + switch (key_cmd) { + case Opt_new: + /* first argument is key size */ + c = strsep(datablob, " \t"); + if (!c) + return -EINVAL; + ret = kstrtol(c, 10, &keylen); + if (ret < 0 || keylen < MIN_KEY_SIZE || keylen > MAX_KEY_SIZE) + return -EINVAL; + p->key_len = keylen; + ret = Opt_new; + break; + case Opt_load: + /* first argument is sealed blob */ + c = strsep(datablob, " \t"); + if (!c) + return -EINVAL; + p->blob_len = strlen(c) / 2; + if (p->blob_len > MAX_BLOB_SIZE) + return -EINVAL; + ret = hex2bin(p->blob, c, p->blob_len); + if (ret < 0) + return -EINVAL; + ret = Opt_load; + break; + case Opt_update: + ret = Opt_update; + break; + case Opt_err: + return -EINVAL; + } + return ret; +} + +static struct trusted_key_payload *trusted_payload_alloc(struct key *key) +{ + struct trusted_key_payload *p = NULL; + int ret; + + ret = key_payload_reserve(key, sizeof(*p)); + if (ret < 0) + goto err; + p = kzalloc(sizeof(*p), GFP_KERNEL); + if (!p) + goto err; + + p->migratable = migratable; +err: + return p; +} + +/* + * trusted_instantiate - create a new trusted key + * + * Unseal an existing trusted blob or, for a new key, get a + * random key, then seal and create a trusted key-type key, + * adding it to the specified keyring. + * + * On success, return 0. Otherwise return errno. + */ +static int trusted_instantiate(struct key *key, + struct key_preparsed_payload *prep) +{ + struct trusted_key_payload *payload = NULL; + size_t datalen = prep->datalen; + char *datablob, *orig_datablob; + int ret = 0; + int key_cmd; + size_t key_len; + + if (datalen <= 0 || datalen > 32767 || !prep->data) + return -EINVAL; + + datablob = kmalloc(datalen + 1, GFP_KERNEL); + orig_datablob = datablob; + if (!datablob) + return -ENOMEM; + memcpy(datablob, prep->data, datalen); + datablob[datalen] = '\0'; + + payload = trusted_payload_alloc(key); + if (!payload) { + ret = -ENOMEM; + goto out; + } + + key_cmd = datablob_parse(&datablob, payload); + if (key_cmd < 0) { + ret = key_cmd; + goto out; + } + + dump_payload(payload); + + switch (key_cmd) { + case Opt_load: + ret = static_call(trusted_key_unseal)(payload, datablob); + dump_payload(payload); + if (ret < 0) + pr_info("key_unseal failed (%d)\n", ret); + break; + case Opt_new: + key_len = payload->key_len; + ret = static_call(trusted_key_get_random)(payload->key, + key_len); + if (ret < 0) + goto out; + + if (ret != key_len) { + pr_info("key_create failed (%d)\n", ret); + ret = -EIO; + goto out; + } + + ret = static_call(trusted_key_seal)(payload, datablob); + if (ret < 0) + pr_info("key_seal failed (%d)\n", ret); + break; + default: + ret = -EINVAL; + } +out: + kfree_sensitive(orig_datablob); + if (!ret) + rcu_assign_keypointer(key, payload); + else + kfree_sensitive(payload); + return ret; +} + +static void trusted_rcu_free(struct rcu_head *rcu) +{ + struct trusted_key_payload *p; + + p = container_of(rcu, struct trusted_key_payload, rcu); + kfree_sensitive(p); +} + +/* + * trusted_update - reseal an existing key with new PCR values + */ +static int trusted_update(struct key *key, struct key_preparsed_payload *prep) +{ + struct trusted_key_payload *p; + struct trusted_key_payload *new_p; + size_t datalen = prep->datalen; + char *datablob, *orig_datablob; + int ret = 0; + + if (key_is_negative(key)) + return -ENOKEY; + p = key->payload.data[0]; + if (!p->migratable) + return -EPERM; + if (datalen <= 0 || datalen > 32767 || !prep->data) + return -EINVAL; + + datablob = kmalloc(datalen + 1, GFP_KERNEL); + orig_datablob = datablob; + if (!datablob) + return -ENOMEM; + + new_p = trusted_payload_alloc(key); + if (!new_p) { + ret = -ENOMEM; + goto out; + } + + memcpy(datablob, prep->data, datalen); + datablob[datalen] = '\0'; + ret = datablob_parse(&datablob, new_p); + if (ret != Opt_update) { + ret = -EINVAL; + kfree_sensitive(new_p); + goto out; + } + + /* copy old key values, and reseal with new pcrs */ + new_p->migratable = p->migratable; + new_p->key_len = p->key_len; + memcpy(new_p->key, p->key, p->key_len); + dump_payload(p); + dump_payload(new_p); + + ret = static_call(trusted_key_seal)(new_p, datablob); + if (ret < 0) { + pr_info("key_seal failed (%d)\n", ret); + kfree_sensitive(new_p); + goto out; + } + + rcu_assign_keypointer(key, new_p); + call_rcu(&p->rcu, trusted_rcu_free); +out: + kfree_sensitive(orig_datablob); + return ret; +} + +/* + * trusted_read - copy the sealed blob data to userspace in hex. + * On success, return to userspace the trusted key datablob size. + */ +static long trusted_read(const struct key *key, char *buffer, + size_t buflen) +{ + const struct trusted_key_payload *p; + char *bufp; + int i; + + p = dereference_key_locked(key); + if (!p) + return -EINVAL; + + if (buffer && buflen >= 2 * p->blob_len) { + bufp = buffer; + for (i = 0; i < p->blob_len; i++) + bufp = hex_byte_pack(bufp, p->blob[i]); + } + return 2 * p->blob_len; +} + +/* + * trusted_destroy - clear and free the key's payload + */ +static void trusted_destroy(struct key *key) +{ + kfree_sensitive(key->payload.data[0]); +} + +struct key_type key_type_trusted = { + .name = "trusted", + .instantiate = trusted_instantiate, + .update = trusted_update, + .destroy = trusted_destroy, + .describe = user_describe, + .read = trusted_read, +}; +EXPORT_SYMBOL_GPL(key_type_trusted); + +static int kernel_get_random(unsigned char *key, size_t key_len) +{ + return get_random_bytes_wait(key, key_len) ?: key_len; +} + +static int __init init_trusted(void) +{ + int (*get_random)(unsigned char *key, size_t key_len); + int i, ret = 0; + + for (i = 0; i < ARRAY_SIZE(trusted_key_sources); i++) { + if (trusted_key_source && + strncmp(trusted_key_source, trusted_key_sources[i].name, + strlen(trusted_key_sources[i].name))) + continue; + + /* + * We always support trusted.rng="kernel" and "default" as + * well as trusted.rng=$trusted.source if the trust source + * defines its own get_random callback. + */ + get_random = trusted_key_sources[i].ops->get_random; + if (trusted_rng && strcmp(trusted_rng, "default")) { + if (!strcmp(trusted_rng, "kernel")) { + get_random = kernel_get_random; + } else if (strcmp(trusted_rng, trusted_key_sources[i].name) || + !get_random) { + if (get_random) + pr_warn("Unsupported RNG. Supported: kernel, %s, default\n", + trusted_key_sources[i].name); + else + pr_warn("Unsupported RNG. Supported: kernel, default\n"); + return -EINVAL; + } + } + + if (!get_random) + get_random = kernel_get_random; + + static_call_update(trusted_key_init, + trusted_key_sources[i].ops->init); + static_call_update(trusted_key_seal, + trusted_key_sources[i].ops->seal); + static_call_update(trusted_key_unseal, + trusted_key_sources[i].ops->unseal); + static_call_update(trusted_key_get_random, + get_random); + static_call_update(trusted_key_exit, + trusted_key_sources[i].ops->exit); + migratable = trusted_key_sources[i].ops->migratable; + + ret = static_call(trusted_key_init)(); + if (!ret) + break; + } + + /* + * encrypted_keys.ko depends on successful load of this module even if + * trusted key implementation is not found. + */ + if (ret == -ENODEV) + return 0; + + return ret; +} + +static void __exit cleanup_trusted(void) +{ + static_call_cond(trusted_key_exit)(); +} + +late_initcall(init_trusted); +module_exit(cleanup_trusted); + +MODULE_LICENSE("GPL"); diff --git a/drivers/aml_trusted_keys/trusted_tee.c b/drivers/aml_trusted_keys/trusted_tee.c new file mode 100644 index 000000000..f6dd90354 --- /dev/null +++ b/drivers/aml_trusted_keys/trusted_tee.c @@ -0,0 +1,432 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2019-2021 Linaro Ltd. + * + * Author: + * Sumit Garg + */ + +#include +#include +#include +#include +#include +#include +#include + +#include + +#define DRIVER_NAME "aml-trusted-key-tee" + +/* + * Get random data for symmetric key + * + * [out] memref[0] Random data + */ +#define TA_CMD_GET_RANDOM 0x0 + +/* + * Seal trusted key using hardware unique key + * + * [in] memref[0] Plain key + * [out] memref[1] Sealed key datablob + */ +#define TA_CMD_SEAL 0x1 + +/* + * Unseal trusted key using hardware unique key + * + * [in] memref[0] Sealed key datablob + * [out] memref[1] Plain key + */ +#define TA_CMD_UNSEAL 0x2 +#define MAX_EXTRA_SIZE (512) +/** + * struct trusted_key_tee_private - TEE Trusted key private data + * @dev: TEE based Trusted key device. + * @ctx: TEE context handler. + * @session_id: Trusted key TA session identifier. + * @shm_pool: Memory pool shared with TEE device. + */ +struct trusted_key_tee_private { + struct device *dev; + struct tee_context *ctx; + u32 session_id; + struct tee_shm *shm_pool; +}; + +static struct trusted_key_tee_private pvt_data; +#define USE_SHM_ALLOC (1) +/* + * Have the TEE seal(encrypt) the symmetric key + */ +static int trusted_tee_seal(struct trusted_key_payload *p, char *datablob) +{ + int ret; + struct tee_ioctl_invoke_arg inv_arg; + struct tee_param param[4]; + struct tee_shm *reg_shm_in = NULL, *reg_shm_out = NULL; +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + struct tee_shm *reg_shm_extra_in = NULL; + u8 extra[MAX_EXTRA_SIZE]; + u32 extra_sz = 0; +#endif + memset(&inv_arg, 0, sizeof(inv_arg)); + memset(¶m, 0, sizeof(param)); +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + memset(extra, 0, sizeof(extra)); +#endif + +#if USE_SHM_ALLOC + reg_shm_in = tee_shm_alloc_kernel_buf(pvt_data.ctx, p->key_len); + if (IS_ERR(reg_shm_in)) { + dev_err(pvt_data.dev, "key shm alloc failed\n"); + return PTR_ERR(reg_shm_in); + } + memcpy(reg_shm_in->kaddr, p->key, p->key_len); + reg_shm_out = tee_shm_alloc_kernel_buf(pvt_data.ctx, sizeof(p->blob)); + if (IS_ERR(reg_shm_out)) { + dev_err(pvt_data.dev, "blob shm register failed\n"); + ret = PTR_ERR(reg_shm_out); + goto out; + } +#else + reg_shm_in = tee_shm_register_kernel_buf(pvt_data.ctx, p->key, + p->key_len); + if (IS_ERR(reg_shm_in)) { + dev_err(pvt_data.dev, "key shm register failed\n"); + return PTR_ERR(reg_shm_in); + } + reg_shm_out = tee_shm_register_kernel_buf(pvt_data.ctx, p->blob, + sizeof(p->blob)); + if (IS_ERR(reg_shm_out)) { + dev_err(pvt_data.dev, "blob shm register failed\n"); + ret = PTR_ERR(reg_shm_out); + goto out; + } +#endif +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + /* set uid as extra */ + if (sizeof(extra) >= sizeof(uid_t)) { + memcpy(extra, &(current_uid().val), sizeof(uid_t)); + extra_sz += sizeof(uid_t); + } else { + dev_err(pvt_data.dev, "extra buf is too small\n"); + } +#if USE_SHM_ALLOC + reg_shm_extra_in = tee_shm_alloc_kernel_buf(pvt_data.ctx, extra_sz); + if (IS_ERR(reg_shm_extra_in)) { + dev_err(pvt_data.dev, "extra shm register failed\n"); + ret = PTR_ERR(reg_shm_extra_in); + goto out; + } + memcpy(reg_shm_extra_in->kaddr, extra, extra_sz); +#else + reg_shm_extra_in = tee_shm_register_kernel_buf(pvt_data.ctx, extra, + extra_sz); + if (IS_ERR(reg_shm_extra_in)) { + dev_err(pvt_data.dev, "extra shm register failed\n"); + ret = PTR_ERR(reg_shm_extra_in); + goto out; + } +#endif +#endif + inv_arg.func = TA_CMD_SEAL; + inv_arg.session = pvt_data.session_id; + inv_arg.num_params = 4; + + param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[0].u.memref.shm = reg_shm_in; + param[0].u.memref.size = p->key_len; + param[0].u.memref.shm_offs = 0; + param[1].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT; + param[1].u.memref.shm = reg_shm_out; + param[1].u.memref.size = sizeof(p->blob); + param[1].u.memref.shm_offs = 0; +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + param[2].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[2].u.memref.shm = reg_shm_extra_in; + param[2].u.memref.size = extra_sz; + param[2].u.memref.shm_offs = 0; +#endif + ret = tee_client_invoke_func(pvt_data.ctx, &inv_arg, param); + if (ret < 0 || inv_arg.ret != 0) { + dev_err(pvt_data.dev, "TA_CMD_SEAL invoke err: %x\n", + inv_arg.ret); + ret = -EFAULT; + } else { + p->blob_len = param[1].u.memref.size; +#if USE_SHM_ALLOC + memcpy(p->blob, reg_shm_out->kaddr, p->blob_len); +#endif + } + +out: + if (reg_shm_out) + tee_shm_free(reg_shm_out); + if (reg_shm_in) + tee_shm_free(reg_shm_in); +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + if (reg_shm_extra_in) + tee_shm_free(reg_shm_extra_in); +#endif + return ret; +} + +/* + * Have the TEE unseal(decrypt) the symmetric key + */ +static int trusted_tee_unseal(struct trusted_key_payload *p, char *datablob) +{ + int ret; + struct tee_ioctl_invoke_arg inv_arg; + struct tee_param param[4]; + struct tee_shm *reg_shm_in = NULL, *reg_shm_out = NULL; +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + struct tee_shm *reg_shm_extra_in = NULL; + u8 extra[MAX_EXTRA_SIZE]; + u32 extra_sz = 0; +#endif + memset(&inv_arg, 0, sizeof(inv_arg)); + memset(¶m, 0, sizeof(param)); +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + memset(extra, 0, sizeof(extra)); +#endif +#if USE_SHM_ALLOC + reg_shm_in = tee_shm_alloc_kernel_buf(pvt_data.ctx, p->blob_len); + if (IS_ERR(reg_shm_in)) { + dev_err(pvt_data.dev, "blob shm register failed\n"); + return PTR_ERR(reg_shm_in); + } + memcpy(reg_shm_in->kaddr, p->blob, p->blob_len); + reg_shm_out = tee_shm_alloc_kernel_buf(pvt_data.ctx, sizeof(p->key)); + if (IS_ERR(reg_shm_out)) { + dev_err(pvt_data.dev, "key shm register failed\n"); + ret = PTR_ERR(reg_shm_out); + goto out; + } +#else + reg_shm_in = tee_shm_register_kernel_buf(pvt_data.ctx, p->blob, + p->blob_len); + if (IS_ERR(reg_shm_in)) { + dev_err(pvt_data.dev, "blob shm register failed\n"); + return PTR_ERR(reg_shm_in); + } + reg_shm_out = tee_shm_register_kernel_buf(pvt_data.ctx, p->key, + sizeof(p->key)); + if (IS_ERR(reg_shm_out)) { + dev_err(pvt_data.dev, "key shm register failed\n"); + ret = PTR_ERR(reg_shm_out); + goto out; + } +#endif +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + if (sizeof(extra) >= sizeof(uid_t)) { + memcpy(extra, &(current_uid().val), sizeof(uid_t)); + extra_sz += sizeof(uid_t); + } else { + dev_err(pvt_data.dev, "extra buf is too small\n"); + } +#if USE_SHM_ALLOC + reg_shm_extra_in = tee_shm_alloc_kernel_buf(pvt_data.ctx, extra_sz); + if (IS_ERR(reg_shm_extra_in)) { + dev_err(pvt_data.dev, "extra shm register failed\n"); + return PTR_ERR(reg_shm_extra_in); + } + memcpy(reg_shm_extra_in->kaddr, extra, extra_sz); +#else + reg_shm_extra_in = tee_shm_register_kernel_buf(pvt_data.ctx, extra, + sizeof(extra)); + if (IS_ERR(reg_shm_extra_in)) { + dev_err(pvt_data.dev, "extra shm register failed\n"); + return PTR_ERR(reg_shm_extra_in); + } +#endif +#endif + inv_arg.func = TA_CMD_UNSEAL; + inv_arg.session = pvt_data.session_id; + inv_arg.num_params = 4; + + param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[0].u.memref.shm = reg_shm_in; + param[0].u.memref.size = p->blob_len; + param[0].u.memref.shm_offs = 0; + param[1].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT; + param[1].u.memref.shm = reg_shm_out; + param[1].u.memref.size = sizeof(p->key); + param[1].u.memref.shm_offs = 0; +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + param[2].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT; + param[2].u.memref.shm = reg_shm_extra_in; + param[2].u.memref.size = extra_sz; + param[2].u.memref.shm_offs = 0; +#endif + ret = tee_client_invoke_func(pvt_data.ctx, &inv_arg, param); + if (ret < 0 || inv_arg.ret != 0) { + dev_err(pvt_data.dev, "TA_CMD_UNSEAL invoke err: %x\n", + inv_arg.ret); + ret = -EFAULT; + } else { + p->key_len = param[1].u.memref.size; +#if USE_SHM_ALLOC + memcpy(p->key, reg_shm_out->kaddr, p->key_len); +#endif + } + +out: + if (reg_shm_out) + tee_shm_free(reg_shm_out); + if (reg_shm_in) + tee_shm_free(reg_shm_in); +#if IS_ENABLED(CONFIG_AMLOGIC_LINUX_FBE_RDK) + if (reg_shm_extra_in) + tee_shm_free(reg_shm_extra_in); +#endif + return ret; +} + +/* + * Have the TEE generate random symmetric key + */ +static int trusted_tee_get_random(unsigned char *key, size_t key_len) +{ + int ret; + struct tee_ioctl_invoke_arg inv_arg; + struct tee_param param[4]; + struct tee_shm *reg_shm = NULL; + + memset(&inv_arg, 0, sizeof(inv_arg)); + memset(¶m, 0, sizeof(param)); + +#if USE_SHM_ALLOC + //dev_err(pvt_data.dev, " USE_SHM_ALLOC\n"); + reg_shm = tee_shm_alloc_kernel_buf(pvt_data.ctx, key_len); +#else + //dev_err(pvt_data.dev, " USE_SHM_REG\n"); + reg_shm = tee_shm_register_kernel_buf(pvt_data.ctx, key, key_len); +#endif + if (IS_ERR(reg_shm)) { + dev_err(pvt_data.dev, "key shm register failed\n"); + return PTR_ERR(reg_shm); + } + + inv_arg.func = TA_CMD_GET_RANDOM; + inv_arg.session = pvt_data.session_id; + inv_arg.num_params = 4; + + param[0].attr = TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT; + param[0].u.memref.shm = reg_shm; + param[0].u.memref.size = key_len; + param[0].u.memref.shm_offs = 0; + + ret = tee_client_invoke_func(pvt_data.ctx, &inv_arg, param); + if (ret < 0 || inv_arg.ret != 0) { + dev_err(pvt_data.dev, "TA_CMD_GET_RANDOM invoke err: %x, %x\n", + inv_arg.ret, inv_arg.ret_origin); + ret = -EFAULT; + } else { + ret = param[0].u.memref.size; +#if USE_SHM_ALLOC + memcpy(key, reg_shm->kaddr, key_len); +#endif + } + + tee_shm_free(reg_shm); + + return ret; +} + +static int optee_ctx_match(struct tee_ioctl_version_data *ver, const void *data) +{ + if (ver->impl_id == TEE_IMPL_ID_OPTEE) + return 1; + else + return 0; +} + +static int trusted_key_probe(struct device *dev) +{ + struct tee_client_device *rng_device = to_tee_client_device(dev); + int ret; + struct tee_ioctl_open_session_arg sess_arg; + + memset(&sess_arg, 0, sizeof(sess_arg)); + + pvt_data.ctx = tee_client_open_context(NULL, optee_ctx_match, NULL, + NULL); + if (IS_ERR(pvt_data.ctx)) + return -ENODEV; + + memcpy(sess_arg.uuid, rng_device->id.uuid.b, TEE_IOCTL_UUID_LEN); + sess_arg.clnt_login = TEE_IOCTL_LOGIN_REE_KERNEL; + sess_arg.num_params = 0; + + ret = tee_client_open_session(pvt_data.ctx, &sess_arg, NULL); + if (ret < 0 || sess_arg.ret != 0) { + dev_err(dev, "tee_client_open_session failed, err: %x\n", + sess_arg.ret); + ret = -EINVAL; + goto out_ctx; + } + pvt_data.session_id = sess_arg.session; + + ret = register_key_type(&key_type_trusted); + if (ret < 0) + goto out_sess; + + pvt_data.dev = dev; + + return 0; + +out_sess: + tee_client_close_session(pvt_data.ctx, pvt_data.session_id); +out_ctx: + tee_client_close_context(pvt_data.ctx); + + return ret; +} + +static int trusted_key_remove(struct device *dev) +{ + unregister_key_type(&key_type_trusted); + tee_client_close_session(pvt_data.ctx, pvt_data.session_id); + tee_client_close_context(pvt_data.ctx); + + return 0; +} + +static const struct tee_client_device_id trusted_key_id_table[] = { + {UUID_INIT(0xf04a0fe7, 0x1f5d, 0x4b9b, + 0xab, 0xf7, 0x61, 0x9b, 0x85, 0xb4, 0xce, 0x8c)}, + {} +}; +MODULE_DEVICE_TABLE(tee, trusted_key_id_table); + +static struct tee_client_driver trusted_key_driver = { + .id_table = trusted_key_id_table, + .driver = { + .name = DRIVER_NAME, + .bus = &tee_bus_type, + .probe = trusted_key_probe, + .remove = trusted_key_remove, + }, +}; + +static int trusted_tee_init(void) +{ + return driver_register(&trusted_key_driver.driver); +} + +static void trusted_tee_exit(void) +{ + driver_unregister(&trusted_key_driver.driver); +} + +struct trusted_key_ops trusted_key_tee_ops = { + .migratable = 0, /* non-migratable */ + .init = trusted_tee_init, + .seal = trusted_tee_seal, + .unseal = trusted_tee_unseal, + .get_random = trusted_tee_get_random, + .exit = trusted_tee_exit, +};