| Message ID | 1565682784-10234-1-git-send-email-sumit.garg@linaro.org |
|---|---|
| Headers | show |
| Series | Add generic trusted keys framework/subsystem | expand |
Hi Mimi, On Wed, 14 Aug 2019 at 18:54, Mimi Zohar <zohar@kernel.org> wrote: > > Hi Sumit, > > On Tue, 2019-08-13 at 13:22 +0530, Sumit Garg wrote: > > This patch-set is an outcome of discussion here [1]. It has evolved very > > much since v1 to create, consolidate and generalize trusted keys > > subsystem. > > > > This framework has been tested with trusted keys support provided via TEE > > but I wasn't able to test it with a TPM device as I don't possess one. It > > would be really helpful if others could test this patch-set using a TPM > > device. > > With the "CONFIG_HEADER_TEST" and "CONFIG_KERNEL_HEADER_TEST" config > options enabled, which is required for linux-next, it fails to build. > TBH, I wasn't aware about this test feature for headers. It looks like the header which fails this test is "include/keys/trusted_tpm.h" which is basically a rename of "include/keys/trusted.h" plus changes in this patch-set. And "include/keys/trusted.h" header is already put under blacklist here: "include/Kbuild +68" as it fails to build. So its that rename due to which build failure is observed now. It seems to be an easy fix for this build failure via following changes: diff --git a/include/keys/trusted_tpm.h b/include/keys/trusted_tpm.h index 7b593447920b..ca1bec0ef65d 100644 --- a/include/keys/trusted_tpm.h +++ b/include/keys/trusted_tpm.h @@ -2,6 +2,9 @@ #ifndef __TRUSTED_TPM_H #define __TRUSTED_TPM_H +#include <keys/trusted-type.h> +#include <linux/tpm_command.h> + /* implementation specific TPM constants */ #define MAX_BUF_SIZE 1024 #define TPM_GETRANDOM_SIZE 14 So I will include above changes in this patch-set and also remove "include/keys/trusted.h" header from the blacklist. -Sumit > Mimi
On Thu, 15 Aug 2019 at 20:36, Mimi Zohar <zohar@kernel.org> wrote: > > On Thu, 2019-08-15 at 18:33 +0530, Sumit Garg wrote: > > Hi Mimi, > > > > On Wed, 14 Aug 2019 at 18:54, Mimi Zohar <zohar@kernel.org> wrote: > > > > > > Hi Sumit, > > > > > > On Tue, 2019-08-13 at 13:22 +0530, Sumit Garg wrote: > > > > This patch-set is an outcome of discussion here [1]. It has evolved very > > > > much since v1 to create, consolidate and generalize trusted keys > > > > subsystem. > > > > > > > > This framework has been tested with trusted keys support provided via TEE > > > > but I wasn't able to test it with a TPM device as I don't possess one. It > > > > would be really helpful if others could test this patch-set using a TPM > > > > device. > > > > > > With the "CONFIG_HEADER_TEST" and "CONFIG_KERNEL_HEADER_TEST" config > > > options enabled, which is required for linux-next, it fails to build. > > > > > > > TBH, I wasn't aware about this test feature for headers. > > It's new to me too. > > > It looks like > > the header which fails this test is "include/keys/trusted_tpm.h" which > > is basically a rename of "include/keys/trusted.h" plus changes in this > > patch-set. > > > > And "include/keys/trusted.h" header is already put under blacklist > > here: "include/Kbuild +68" as it fails to build. So its that rename > > due to which build failure is observed now. > > > > It seems to be an easy fix for this build failure via following changes: > > > > diff --git a/include/keys/trusted_tpm.h b/include/keys/trusted_tpm.h > > index 7b593447920b..ca1bec0ef65d 100644 > > --- a/include/keys/trusted_tpm.h > > +++ b/include/keys/trusted_tpm.h > > @@ -2,6 +2,9 @@ > > #ifndef __TRUSTED_TPM_H > > #define __TRUSTED_TPM_H > > > > +#include <keys/trusted-type.h> > > +#include <linux/tpm_command.h> > > + > > /* implementation specific TPM constants */ > > #define MAX_BUF_SIZE 1024 > > #define TPM_GETRANDOM_SIZE 14 > > > > So I will include above changes in this patch-set and also remove > > "include/keys/trusted.h" header from the blacklist. > > That works, thanks. With this patch set, at least the EVM trusted key > is properly being decrypted by the encrypted key with both a TPM 1.2 > and PTT TPM 2.0. My laptop still boots properly. Over the weekend > I'll try to actually review the patches. > Thanks Mimi for testing this patch-set. -Sumit > Mimi
On Tue, Aug 13, 2019 at 01:23:01PM +0530, Sumit Garg wrote: > Utilize common heap based tpm_buf code for TPM1.x trusted keys rather > than using stack based tpm1_buf code. Also, remove tpm1_buf code. > > Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> > Signed-off-by: Sumit Garg <sumit.garg@linaro.org> Reviewed-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> /Jarkko
On Tue, Aug 20, 2019 at 11:16:46AM +0530, Sumit Garg wrote: > I agree here that 5/5 should go along with TEE patch-set. But if you > look at initial v1 patch-set, the idea was to get feedback on trusted > keys abstraction as a standalone patch along with testing using a TPM > (1.x or 2.0). > > Since Mimi has tested this patch-set with TPM (1.x & 2.0), I am happy > to merge 5/5 with TEE patch-set. But it would be nice if I could get > feedback on 5/5 before I send next version of TEE patch-set. OK, that is understandable. I'll check it out tomorrow. /Jarkko
On Tue, 13 Aug 2019 at 13:24, Sumit Garg <sumit.garg@linaro.org> wrote: > > Current trusted keys framework is tightly coupled to use TPM device as > an underlying implementation which makes it difficult for implementations > like Trusted Execution Environment (TEE) etc. to provide trusked keys > support in case platform doesn't posses a TPM device. > > So this patch tries to add generic trusted keys framework where underlying > implemtations like TPM, TEE etc. could be easily plugged-in. > > Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> > Signed-off-by: Sumit Garg <sumit.garg@linaro.org> > --- > include/keys/trusted-type.h | 45 ++++ > include/keys/trusted_tpm.h | 15 -- > security/keys/trusted-keys/Makefile | 1 + > security/keys/trusted-keys/trusted-common.c | 343 +++++++++++++++++++++++++++ > security/keys/trusted-keys/trusted-tpm.c | 345 +++++----------------------- > 5 files changed, 447 insertions(+), 302 deletions(-) > create mode 100644 security/keys/trusted-keys/trusted-common.c > Any comments/feedback on this patch before I send next version of TEE patch-set with this patch included? -Sumit > diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h > index a94c03a..5559010 100644 > --- a/include/keys/trusted-type.h > +++ b/include/keys/trusted-type.h > @@ -40,6 +40,51 @@ struct trusted_key_options { > uint32_t policyhandle; > }; > > +struct trusted_key_ops { > + /* > + * flag to indicate if trusted key implementation supports migration > + * or not. > + */ > + unsigned char migratable; > + > + /* trusted key init */ > + int (*init)(void); > + > + /* seal a trusted key */ > + int (*seal)(struct trusted_key_payload *p, char *datablob); > + > + /* unseal a trusted key */ > + int (*unseal)(struct trusted_key_payload *p, char *datablob); > + > + /* get random trusted key */ > + int (*get_random)(unsigned char *key, size_t key_len); > + > + /* trusted key cleanup */ > + void (*cleanup)(void); > +}; > + > extern struct key_type key_type_trusted; > +#if defined(CONFIG_TCG_TPM) > +extern struct trusted_key_ops tpm_trusted_key_ops; > +#endif > + > +#define TRUSTED_DEBUG 0 > + > +#if TRUSTED_DEBUG > +static inline void dump_payload(struct trusted_key_payload *p) > +{ > + pr_info("trusted_key: key_len %d\n", p->key_len); > + print_hex_dump(KERN_INFO, "key ", DUMP_PREFIX_NONE, > + 16, 1, p->key, p->key_len, 0); > + pr_info("trusted_key: bloblen %d\n", p->blob_len); > + print_hex_dump(KERN_INFO, "blob ", DUMP_PREFIX_NONE, > + 16, 1, p->blob, p->blob_len, 0); > + pr_info("trusted_key: migratable %d\n", p->migratable); > +} > +#else > +static inline void dump_payload(struct trusted_key_payload *p) > +{ > +} > +#endif > > #endif /* _KEYS_TRUSTED_TYPE_H */ > diff --git a/include/keys/trusted_tpm.h b/include/keys/trusted_tpm.h > index 0d72106..7b59344 100644 > --- a/include/keys/trusted_tpm.h > +++ b/include/keys/trusted_tpm.h > @@ -57,17 +57,6 @@ static inline void dump_options(struct trusted_key_options *o) > 16, 1, o->pcrinfo, o->pcrinfo_len, 0); > } > > -static inline void dump_payload(struct trusted_key_payload *p) > -{ > - pr_info("trusted_key: key_len %d\n", p->key_len); > - print_hex_dump(KERN_INFO, "key ", DUMP_PREFIX_NONE, > - 16, 1, p->key, p->key_len, 0); > - pr_info("trusted_key: bloblen %d\n", p->blob_len); > - print_hex_dump(KERN_INFO, "blob ", DUMP_PREFIX_NONE, > - 16, 1, p->blob, p->blob_len, 0); > - pr_info("trusted_key: migratable %d\n", p->migratable); > -} > - > static inline void dump_sess(struct osapsess *s) > { > print_hex_dump(KERN_INFO, "trusted-key: handle ", DUMP_PREFIX_NONE, > @@ -93,10 +82,6 @@ static inline void dump_options(struct trusted_key_options *o) > { > } > > -static inline void dump_payload(struct trusted_key_payload *p) > -{ > -} > - > static inline void dump_sess(struct osapsess *s) > { > } > diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-keys/Makefile > index fb42e94..9a4f721 100644 > --- a/security/keys/trusted-keys/Makefile > +++ b/security/keys/trusted-keys/Makefile > @@ -4,5 +4,6 @@ > # > > obj-$(CONFIG_TRUSTED_KEYS) += trusted.o > +trusted-y += trusted-common.o > trusted-y += trusted-tpm.o > trusted-y += trusted-tpm2.o > diff --git a/security/keys/trusted-keys/trusted-common.c b/security/keys/trusted-keys/trusted-common.c > new file mode 100644 > index 0000000..8f00fde > --- /dev/null > +++ b/security/keys/trusted-keys/trusted-common.c > @@ -0,0 +1,343 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Copyright (C) 2010 IBM Corporation > + * Copyright (c) 2019, Linaro Limited > + * > + * Author: > + * David Safford <safford@us.ibm.com> > + * Added generic trusted key framework: Sumit Garg <sumit.garg@linaro.org> > + * > + * See Documentation/security/keys/trusted-encrypted.rst > + */ > + > +#include <keys/user-type.h> > +#include <keys/trusted-type.h> > +#include <linux/capability.h> > +#include <linux/err.h> > +#include <linux/init.h> > +#include <linux/key-type.h> > +#include <linux/module.h> > +#include <linux/parser.h> > +#include <linux/rcupdate.h> > +#include <linux/slab.h> > +#include <linux/string.h> > +#include <linux/uaccess.h> > + > +static struct trusted_key_ops *available_tk_ops[] = { > +#if defined(CONFIG_TCG_TPM) > + &tpm_trusted_key_ops, > +#endif > +}; > +static struct trusted_key_ops *tk_ops; > + > +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) > + return p; > + p = kzalloc(sizeof(*p), GFP_KERNEL); > + > + p->migratable = tk_ops->migratable; > + > + 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; > + 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); > + 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 = tk_ops->unseal(payload, datablob); > + dump_payload(payload); > + if (ret < 0) > + pr_info("trusted_key: key_unseal failed (%d)\n", ret); > + break; > + case Opt_new: > + key_len = payload->key_len; > + ret = tk_ops->get_random(payload->key, key_len); > + if (ret != key_len) { > + pr_info("trusted_key: key_create failed (%d)\n", ret); > + goto out; > + } > + > + ret = tk_ops->seal(payload, datablob); > + if (ret < 0) > + pr_info("trusted_key: key_seal failed (%d)\n", ret); > + break; > + default: > + ret = -EINVAL; > + } > +out: > + kzfree(datablob); > + if (!ret) > + rcu_assign_keypointer(key, payload); > + else > + kzfree(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); > + kzfree(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; > + 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); > + 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; > + kzfree(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 = tk_ops->seal(new_p, datablob); > + if (ret < 0) { > + pr_info("trusted_key: key_seal failed (%d)\n", ret); > + kzfree(new_p); > + goto out; > + } > + > + rcu_assign_keypointer(key, new_p); > + call_rcu(&p->rcu, trusted_rcu_free); > +out: > + kzfree(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 __user *buffer, > + size_t buflen) > +{ > + const struct trusted_key_payload *p; > + char *ascii_buf; > + char *bufp; > + int i; > + > + p = dereference_key_locked(key); > + if (!p) > + return -EINVAL; > + > + if (buffer && buflen >= 2 * p->blob_len) { > + ascii_buf = kmalloc_array(2, p->blob_len, GFP_KERNEL); > + if (!ascii_buf) > + return -ENOMEM; > + > + bufp = ascii_buf; > + for (i = 0; i < p->blob_len; i++) > + bufp = hex_byte_pack(bufp, p->blob[i]); > + if (copy_to_user(buffer, ascii_buf, 2 * p->blob_len) != 0) { > + kzfree(ascii_buf); > + return -EFAULT; > + } > + kzfree(ascii_buf); > + } > + return 2 * p->blob_len; > +} > + > +/* > + * trusted_destroy - clear and free the key's payload > + */ > +static void trusted_destroy(struct key *key) > +{ > + kzfree(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 __init init_trusted(void) > +{ > + int i, ret = 0; > + > + for (i = 0; i < sizeof(available_tk_ops); i++) { > + tk_ops = available_tk_ops[i]; > + > + if (!(tk_ops && tk_ops->init && tk_ops->seal && > + tk_ops->unseal && tk_ops->get_random)) > + continue; > + > + ret = tk_ops->init(); > + if (ret) { > + if (tk_ops->cleanup) > + tk_ops->cleanup(); > + } else { > + 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) > +{ > + if (tk_ops->cleanup) > + tk_ops->cleanup(); > +} > + > +late_initcall(init_trusted); > +module_exit(cleanup_trusted); > + > +MODULE_LICENSE("GPL"); > diff --git a/security/keys/trusted-keys/trusted-tpm.c b/security/keys/trusted-keys/trusted-tpm.c > index 66687e7..dab7c32 100644 > --- a/security/keys/trusted-keys/trusted-tpm.c > +++ b/security/keys/trusted-keys/trusted-tpm.c > @@ -1,29 +1,26 @@ > // SPDX-License-Identifier: GPL-2.0-only > /* > * Copyright (C) 2010 IBM Corporation > + * Copyright (c) 2019, Linaro Limited > * > * Author: > * David Safford <safford@us.ibm.com> > + * Switch to generic trusted key framework: Sumit Garg <sumit.garg@linaro.org> > * > * See Documentation/security/keys/trusted-encrypted.rst > */ > > #include <crypto/hash_info.h> > -#include <linux/uaccess.h> > -#include <linux/module.h> > #include <linux/init.h> > #include <linux/slab.h> > #include <linux/parser.h> > #include <linux/string.h> > #include <linux/err.h> > -#include <keys/user-type.h> > #include <keys/trusted-type.h> > #include <linux/key-type.h> > -#include <linux/rcupdate.h> > #include <linux/crypto.h> > #include <crypto/hash.h> > #include <crypto/sha.h> > -#include <linux/capability.h> > #include <linux/tpm.h> > #include <linux/tpm_command.h> > > @@ -705,7 +702,6 @@ static int key_unseal(struct trusted_key_payload *p, > > enum { > Opt_err, > - Opt_new, Opt_load, Opt_update, > Opt_keyhandle, Opt_keyauth, Opt_blobauth, > Opt_pcrinfo, Opt_pcrlock, Opt_migratable, > Opt_hash, > @@ -714,9 +710,6 @@ enum { > }; > > static const match_table_t key_tokens = { > - {Opt_new, "new"}, > - {Opt_load, "load"}, > - {Opt_update, "update"}, > {Opt_keyhandle, "keyhandle=%s"}, > {Opt_keyauth, "keyauth=%s"}, > {Opt_blobauth, "blobauth=%s"}, > @@ -843,71 +836,6 @@ static int getoptions(char *c, struct trusted_key_payload *pay, > return 0; > } > > -/* > - * datablob_parse - parse the keyctl data and fill in the > - * payload and options structures > - * > - * On success returns 0, otherwise -EINVAL. > - */ > -static int datablob_parse(char *datablob, struct trusted_key_payload *p, > - struct trusted_key_options *o) > -{ > - 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 = getoptions(datablob, p, o); > - if (ret < 0) > - return ret; > - 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 = getoptions(datablob, p, o); > - if (ret < 0) > - return ret; > - ret = Opt_load; > - break; > - case Opt_update: > - /* all arguments are options */ > - ret = getoptions(datablob, p, o); > - if (ret < 0) > - return ret; > - ret = Opt_update; > - break; > - case Opt_err: > - return -EINVAL; > - break; > - } > - return ret; > -} > - > static struct trusted_key_options *trusted_options_alloc(void) > { > struct trusted_key_options *options; > @@ -928,258 +856,99 @@ static struct trusted_key_options *trusted_options_alloc(void) > return options; > } > > -static struct trusted_key_payload *trusted_payload_alloc(struct key *key) > +static int tpm_tk_seal(struct trusted_key_payload *p, char *datablob) > { > - struct trusted_key_payload *p = NULL; > - int ret; > - > - ret = key_payload_reserve(key, sizeof *p); > - if (ret < 0) > - return p; > - p = kzalloc(sizeof *p, GFP_KERNEL); > - if (p) > - p->migratable = 1; /* migratable by default */ > - 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; > struct trusted_key_options *options = NULL; > - size_t datalen = prep->datalen; > - char *datablob; > int ret = 0; > - int key_cmd; > - size_t key_len; > int tpm2; > > tpm2 = tpm_is_tpm2(chip); > if (tpm2 < 0) > return tpm2; > > - if (datalen <= 0 || datalen > 32767 || !prep->data) > - return -EINVAL; > - > - datablob = kmalloc(datalen + 1, GFP_KERNEL); > - if (!datablob) > - return -ENOMEM; > - memcpy(datablob, prep->data, datalen); > - datablob[datalen] = '\0'; > - > options = trusted_options_alloc(); > - if (!options) { > - ret = -ENOMEM; > - goto out; > - } > - payload = trusted_payload_alloc(key); > - if (!payload) { > - ret = -ENOMEM; > - goto out; > - } > + if (!options) > + return -ENOMEM; > > - key_cmd = datablob_parse(datablob, payload, options); > - if (key_cmd < 0) { > - ret = key_cmd; > + ret = getoptions(datablob, p, options); > + if (ret < 0) > goto out; > - } > + dump_options(options); > > if (!options->keyhandle) { > ret = -EINVAL; > goto out; > } > > - dump_payload(payload); > - dump_options(options); > + if (tpm2) > + ret = tpm_seal_trusted(chip, p, options); > + else > + ret = key_seal(p, options); > + if (ret < 0) { > + pr_info("tpm_trusted_key: key_seal failed (%d)\n", ret); > + goto out; > + } > > - switch (key_cmd) { > - case Opt_load: > - if (tpm2) > - ret = tpm_unseal_trusted(chip, payload, options); > - else > - ret = key_unseal(payload, options); > - dump_payload(payload); > - dump_options(options); > - if (ret < 0) > - pr_info("trusted_key: key_unseal failed (%d)\n", ret); > - break; > - case Opt_new: > - key_len = payload->key_len; > - ret = tpm_get_random(chip, payload->key, key_len); > - if (ret != key_len) { > - pr_info("trusted_key: key_create failed (%d)\n", ret); > + if (options->pcrlock) { > + ret = pcrlock(options->pcrlock); > + if (ret < 0) { > + pr_info("tpm_trusted_key: pcrlock failed (%d)\n", ret); > goto out; > } > - if (tpm2) > - ret = tpm_seal_trusted(chip, payload, options); > - else > - ret = key_seal(payload, options); > - if (ret < 0) > - pr_info("trusted_key: key_seal failed (%d)\n", ret); > - break; > - default: > - ret = -EINVAL; > - goto out; > } > - if (!ret && options->pcrlock) > - ret = pcrlock(options->pcrlock); > out: > - kzfree(datablob); > kzfree(options); > - if (!ret) > - rcu_assign_keypointer(key, payload); > - else > - kzfree(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); > - kzfree(p); > -} > - > -/* > - * trusted_update - reseal an existing key with new PCR values > - */ > -static int trusted_update(struct key *key, struct key_preparsed_payload *prep) > +static int tpm_tk_unseal(struct trusted_key_payload *p, char *datablob) > { > - struct trusted_key_payload *p; > - struct trusted_key_payload *new_p; > - struct trusted_key_options *new_o; > - size_t datalen = prep->datalen; > - char *datablob; > + struct trusted_key_options *options = NULL; > int ret = 0; > + int tpm2; > > - 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; > + tpm2 = tpm_is_tpm2(chip); > + if (tpm2 < 0) > + return tpm2; > > - datablob = kmalloc(datalen + 1, GFP_KERNEL); > - if (!datablob) > + options = trusted_options_alloc(); > + if (!options) > return -ENOMEM; > - new_o = trusted_options_alloc(); > - if (!new_o) { > - ret = -ENOMEM; > - goto out; > - } > - 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, new_o); > - if (ret != Opt_update) { > - ret = -EINVAL; > - kzfree(new_p); > + ret = getoptions(datablob, p, options); > + if (ret < 0) > goto out; > - } > + dump_options(options); > > - if (!new_o->keyhandle) { > + if (!options->keyhandle) { > ret = -EINVAL; > - kzfree(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); > + if (tpm2) > + ret = tpm_unseal_trusted(chip, p, options); > + else > + ret = key_unseal(p, options); > + if (ret < 0) > + pr_info("tpm_trusted_key: key_unseal failed (%d)\n", ret); > > - ret = key_seal(new_p, new_o); > - if (ret < 0) { > - pr_info("trusted_key: key_seal failed (%d)\n", ret); > - kzfree(new_p); > - goto out; > - } > - if (new_o->pcrlock) { > - ret = pcrlock(new_o->pcrlock); > + if (options->pcrlock) { > + ret = pcrlock(options->pcrlock); > if (ret < 0) { > - pr_info("trusted_key: pcrlock failed (%d)\n", ret); > - kzfree(new_p); > + pr_info("tpm_trusted_key: pcrlock failed (%d)\n", ret); > goto out; > } > } > - rcu_assign_keypointer(key, new_p); > - call_rcu(&p->rcu, trusted_rcu_free); > out: > - kzfree(datablob); > - kzfree(new_o); > + kzfree(options); > 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 __user *buffer, > - size_t buflen) > -{ > - const struct trusted_key_payload *p; > - char *ascii_buf; > - char *bufp; > - int i; > - > - p = dereference_key_locked(key); > - if (!p) > - return -EINVAL; > - > - if (buffer && buflen >= 2 * p->blob_len) { > - ascii_buf = kmalloc_array(2, p->blob_len, GFP_KERNEL); > - if (!ascii_buf) > - return -ENOMEM; > - > - bufp = ascii_buf; > - for (i = 0; i < p->blob_len; i++) > - bufp = hex_byte_pack(bufp, p->blob[i]); > - if (copy_to_user(buffer, ascii_buf, 2 * p->blob_len) != 0) { > - kzfree(ascii_buf); > - return -EFAULT; > - } > - kzfree(ascii_buf); > - } > - return 2 * p->blob_len; > -} > - > -/* > - * trusted_destroy - clear and free the key's payload > - */ > -static void trusted_destroy(struct key *key) > +int tpm_tk_get_random(unsigned char *key, size_t key_len) > { > - kzfree(key->payload.data[0]); > + return tpm_get_random(chip, key, key_len); > } > > -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 void trusted_shash_release(void) > { > if (hashalg) > @@ -1194,14 +963,14 @@ static int __init trusted_shash_alloc(void) > > hmacalg = crypto_alloc_shash(hmac_alg, 0, 0); > if (IS_ERR(hmacalg)) { > - pr_info("trusted_key: could not allocate crypto %s\n", > + pr_info("tpm_trusted_key: could not allocate crypto %s\n", > hmac_alg); > return PTR_ERR(hmacalg); > } > > hashalg = crypto_alloc_shash(hash_alg, 0, 0); > if (IS_ERR(hashalg)) { > - pr_info("trusted_key: could not allocate crypto %s\n", > + pr_info("tpm_trusted_key: could not allocate crypto %s\n", > hash_alg); > ret = PTR_ERR(hashalg); > goto hashalg_fail; > @@ -1237,16 +1006,13 @@ static int __init init_digests(void) > return 0; > } > > -static int __init init_trusted(void) > +static int __init init_tpm_trusted(void) > { > int ret; > > - /* encrypted_keys.ko depends on successful load of this module even if > - * TPM is not used. > - */ > chip = tpm_default_chip(); > if (!chip) > - return 0; > + return -ENODEV; > > ret = init_digests(); > if (ret < 0) > @@ -1267,7 +1033,7 @@ static int __init init_trusted(void) > return ret; > } > > -static void __exit cleanup_trusted(void) > +static void __exit cleanup_tpm_trusted(void) > { > if (chip) { > put_device(&chip->dev); > @@ -1277,7 +1043,12 @@ static void __exit cleanup_trusted(void) > } > } > > -late_initcall(init_trusted); > -module_exit(cleanup_trusted); > - > -MODULE_LICENSE("GPL"); > +struct trusted_key_ops tpm_trusted_key_ops = { > + .migratable = 1, /* migratable by default */ > + .init = init_tpm_trusted, > + .seal = tpm_tk_seal, > + .unseal = tpm_tk_unseal, > + .get_random = tpm_tk_get_random, > + .cleanup = cleanup_tpm_trusted, > +}; > +EXPORT_SYMBOL_GPL(tpm_trusted_key_ops); > -- > 2.7.4 >
On Fri, Aug 30, 2019 at 02:49:31PM +0530, Sumit Garg wrote: > Any comments/feedback on this patch before I send next version of TEE > patch-set with this patch included? Unfortunately don't have time before LPC to go deep with the follow up. I will look into this in detail after LPC. /JArkko
On Fri, Aug 30, 2019 at 08:20:31PM +0300, Jarkko Sakkinen wrote: > On Fri, Aug 30, 2019 at 02:49:31PM +0530, Sumit Garg wrote: > > Any comments/feedback on this patch before I send next version of TEE > > patch-set with this patch included? > > Unfortunately don't have time before LPC to go deep with the follow up. > > I will look into this in detail after LPC. I'll ping you once your first row of patches are in my tree so you can rebase these on top of that. /JArkko
On Fri, 30 Aug 2019 at 22:54, Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> wrote: > > On Fri, Aug 30, 2019 at 08:20:31PM +0300, Jarkko Sakkinen wrote: > > On Fri, Aug 30, 2019 at 02:49:31PM +0530, Sumit Garg wrote: > > > Any comments/feedback on this patch before I send next version of TEE > > > patch-set with this patch included? > > > > Unfortunately don't have time before LPC to go deep with the follow up. > > > > I will look into this in detail after LPC. No worries, I will wait for your feedback. > > I'll ping you once your first row of patches are in my tree so you > can rebase these on top of that. > Thanks. -Sumit > /JArkko
This patch-set is an outcome of discussion here [1]. It has evolved very much since v1 to create, consolidate and generalize trusted keys subsystem. This framework has been tested with trusted keys support provided via TEE but I wasn't able to test it with a TPM device as I don't possess one. It would be really helpful if others could test this patch-set using a TPM device. [1] https://www.mail-archive.com/linux-doc@vger.kernel.org/msg30591.html Changes in v4: 1. Separate patch for export of tpm_buf code to include/linux/tpm.h 2. Change TPM1.x trusted keys code to use common tpm_buf 3. Keep module name as trusted.ko only Changes in v3: Move TPM2 trusted keys code to trusted keys subsystem. Changes in v2: Split trusted keys abstraction patch for ease of review. Sumit Garg (5): tpm: move tpm_buf code to include/linux/ KEYS: trusted: use common tpm_buf for TPM1.x code KEYS: trusted: create trusted keys subsystem KEYS: trusted: move tpm2 trusted keys code KEYS: trusted: Add generic trusted keys framework crypto/asymmetric_keys/asym_tpm.c | 2 +- drivers/char/tpm/tpm-chip.c | 1 + drivers/char/tpm/tpm-interface.c | 56 --- drivers/char/tpm/tpm.h | 230 ----------- drivers/char/tpm/tpm2-cmd.c | 308 +-------------- include/keys/trusted-type.h | 45 +++ include/keys/{trusted.h => trusted_tpm.h} | 61 +-- include/linux/tpm.h | 270 ++++++++++++- security/keys/Makefile | 2 +- security/keys/trusted-keys/Makefile | 9 + security/keys/trusted-keys/trusted-common.c | 343 ++++++++++++++++ .../keys/{trusted.c => trusted-keys/trusted-tpm.c} | 437 +++++---------------- security/keys/trusted-keys/trusted-tpm2.c | 378 ++++++++++++++++++ 13 files changed, 1141 insertions(+), 1001 deletions(-) rename include/keys/{trusted.h => trusted_tpm.h} (64%) create mode 100644 security/keys/trusted-keys/Makefile create mode 100644 security/keys/trusted-keys/trusted-common.c rename security/keys/{trusted.c => trusted-keys/trusted-tpm.c} (72%) create mode 100644 security/keys/trusted-keys/trusted-tpm2.c -- 2.7.4