| Message ID | 1602065268-26017-2-git-send-email-sumit.garg@linaro.org (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | Introduce TEE based Trusted Keys support | expand |
On Wed, Oct 07, 2020 at 03:37:45PM +0530, Sumit Garg 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 trusted keys > support in case platform doesn't posses a TPM device. > > Add a generic trusted keys framework where underlying implementations > can be easily plugged in. Create struct trusted_key_ops to achieve this, > which contains necessary functions of a backend. > > Also, add a module parameter in order to select a particular trust source > in case a platform support multiple trust sources. > > Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> > Signed-off-by: Sumit Garg <sumit.garg@linaro.org> This is exactly kind of place where I think static_call() should be taken into use, which is a v5.10 feature [1]. For background and context, I'd read [2]. The other thing that I see that does not make much else than additional complexity, is trusted_tpm.ko. We can do with one trusted.ko. I'd also *guess* that the static_call() mechanism does not work accross module boundaries. [1] https://lore.kernel.org/lkml/20201012155542.GA3557765@gmail.com/ [2] https://lwn.net/Articles/815908/ /Jarkko
On Tue, 13 Oct 2020 at 07:13, Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> wrote: > > On Wed, Oct 07, 2020 at 03:37:45PM +0530, Sumit Garg 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 trusted keys > > support in case platform doesn't posses a TPM device. > > > > Add a generic trusted keys framework where underlying implementations > > can be easily plugged in. Create struct trusted_key_ops to achieve this, > > which contains necessary functions of a backend. > > > > Also, add a module parameter in order to select a particular trust source > > in case a platform support multiple trust sources. > > > > Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> > > Signed-off-by: Sumit Garg <sumit.garg@linaro.org> > > This is exactly kind of place where I think static_call() should be > taken into use, which is a v5.10 feature [1]. For background and > context, I'd read [2]. This looks like an interesting feature. But I am not sure about the real benefits that it will provide in case of trusted keys. If we are looking at it performance wise then I think the gain will be negligible when compared with slow TPM communication interface (eg. SPI, I2C) or when compared with context switching involved in TEE. Also, it requires arch specific support too which currently seems to be limited to x86 only. > > The other thing that I see that does not make much else than additional > complexity, is trusted_tpm.ko. We can do with one trusted.ko. > Current implementation only builds a single trusted.ko module. There isn't any trusted_tpm.ko. -Sumit > I'd also *guess* that the static_call() mechanism does not work accross > module boundaries. > > [1] https://lore.kernel.org/lkml/20201012155542.GA3557765@gmail.com/ > [2] https://lwn.net/Articles/815908/ > > /Jarkko
On Tue, Oct 13, 2020 at 04:23:36PM +0530, Sumit Garg wrote: > On Tue, 13 Oct 2020 at 07:13, Jarkko Sakkinen > <jarkko.sakkinen@linux.intel.com> wrote: > > > > On Wed, Oct 07, 2020 at 03:37:45PM +0530, Sumit Garg 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 trusted keys > > > support in case platform doesn't posses a TPM device. > > > > > > Add a generic trusted keys framework where underlying implementations > > > can be easily plugged in. Create struct trusted_key_ops to achieve this, > > > which contains necessary functions of a backend. > > > > > > Also, add a module parameter in order to select a particular trust source > > > in case a platform support multiple trust sources. > > > > > > Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> > > > Signed-off-by: Sumit Garg <sumit.garg@linaro.org> > > > > This is exactly kind of place where I think static_call() should be > > taken into use, which is a v5.10 feature [1]. For background and > > context, I'd read [2]. > > This looks like an interesting feature. But I am not sure about the > real benefits that it will provide in case of trusted keys. If we are > looking at it performance wise then I think the gain will be > negligible when compared with slow TPM communication interface (eg. > SPI, I2C) or when compared with context switching involved in TEE. > > Also, it requires arch specific support too which currently seems to > be limited to x86 only. Please, do not purposely add indirect calls, unless you must. Here it's not a must. static_call() is the correct kernel idiom to define what you are doing in this patch. arch's will catch up. > > The other thing that I see that does not make much else than additional > > complexity, is trusted_tpm.ko. We can do with one trusted.ko. > > > > Current implementation only builds a single trusted.ko module. There > isn't any trusted_tpm.ko. > -Sumit You're right, I'm sorry. I misread this: -static void __exit cleanup_trusted(void) +static void __exit exit_tpm_trusted(void) { if (chip) { put_device(&chip->dev); @@ -1257,7 +1029,11 @@ 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_trusted_seal, + .unseal = tpm_trusted_unseal, + .get_random = tpm_trusted_get_random, + .exit = exit_tpm_trusted, +}; Please remove "__init" and "__exit" for the functions as they are used as fields as members of a struct that has neither life span. That messed up my head. Please use a single convention for the function names. It would be optimal to prefix with the subsystem name because that makes easier to use tracing tools: trusted_tpm_<callback name> would work. /Jarkko
On Tue, 13 Oct 2020 at 17:29, Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> wrote: > > On Tue, Oct 13, 2020 at 04:23:36PM +0530, Sumit Garg wrote: > > On Tue, 13 Oct 2020 at 07:13, Jarkko Sakkinen > > <jarkko.sakkinen@linux.intel.com> wrote: > > > > > > On Wed, Oct 07, 2020 at 03:37:45PM +0530, Sumit Garg 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 trusted keys > > > > support in case platform doesn't posses a TPM device. > > > > > > > > Add a generic trusted keys framework where underlying implementations > > > > can be easily plugged in. Create struct trusted_key_ops to achieve this, > > > > which contains necessary functions of a backend. > > > > > > > > Also, add a module parameter in order to select a particular trust source > > > > in case a platform support multiple trust sources. > > > > > > > > Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> > > > > Signed-off-by: Sumit Garg <sumit.garg@linaro.org> > > > > > > This is exactly kind of place where I think static_call() should be > > > taken into use, which is a v5.10 feature [1]. For background and > > > context, I'd read [2]. > > > > This looks like an interesting feature. But I am not sure about the > > real benefits that it will provide in case of trusted keys. If we are > > looking at it performance wise then I think the gain will be > > negligible when compared with slow TPM communication interface (eg. > > SPI, I2C) or when compared with context switching involved in TEE. > > > > Also, it requires arch specific support too which currently seems to > > be limited to x86 only. > > Please, do not purposely add indirect calls, unless you must. Here it's > not a must. > > static_call() is the correct kernel idiom to define what you are doing > in this patch. arch's will catch up. Okay, fair enough. I will try to use it instead. > > > > The other thing that I see that does not make much else than additional > > > complexity, is trusted_tpm.ko. We can do with one trusted.ko. > > > > > > > Current implementation only builds a single trusted.ko module. There > > isn't any trusted_tpm.ko. > > -Sumit > > You're right, I'm sorry. I misread this: > > -static void __exit cleanup_trusted(void) > +static void __exit exit_tpm_trusted(void) > { > if (chip) { > put_device(&chip->dev); > @@ -1257,7 +1029,11 @@ 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_trusted_seal, > + .unseal = tpm_trusted_unseal, > + .get_random = tpm_trusted_get_random, > + .exit = exit_tpm_trusted, > +}; > > Please remove "__init" and "__exit" for the functions as they are used > as fields as members of a struct that has neither life span. That messed > up my head. Okay. > > Please use a single convention for the function names. It would > be optimal to prefix with the subsystem name because that makes easier > to use tracing tools: trusted_tpm_<callback name> would work. > Okay. -Sumit > /Jarkko
On Wed, 2020-10-07 at 15:37 +0530, Sumit Garg wrote: > +/* > + * 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 __init init_trusted(void) > +{ > + 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; > + > + trusted_key_ops = trusted_key_sources[i].ops; > + > + ret = trusted_key_ops->init(); > + if (!ret) > + break; > + } In the case when the module paramater isn't specified and both TPM and TEE are enabled, trusted_key_ops is set to the last source initialized. After patch 2/4, the last trusted source initialized is TEE. If the intention is to limit it to either TPM or TEE, then trusted_key_ops should have a default value, which could be overwritten at runtime. That would address Luke Hind's concerns of making the decision at compile time. trusted_key_ops should be defined as __ro_after_init, like is currently done for other LSM structures. > + > + /* > + * 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) > +{ > + trusted_key_ops->exit(); If the intention is really to support both TPM and TEE trusted keys at the same time, as James suggested, then the same "for" loop as in init_trusted() is needed here and probably elsewhere. thanks, Mimi
Thanks Mimi for your comments. On Wed, 21 Oct 2020 at 08:51, Mimi Zohar <zohar@linux.ibm.com> wrote: > > On Wed, 2020-10-07 at 15:37 +0530, Sumit Garg wrote: > > > +/* > > + * 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 __init init_trusted(void) > > +{ > > + 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; > > + > > + trusted_key_ops = trusted_key_sources[i].ops; > > + > > + ret = trusted_key_ops->init(); > > + if (!ret) > > + break; > > + } > > In the case when the module paramater isn't specified and both TPM and > TEE are enabled, trusted_key_ops is set to the last source initialized. I guess there is some misunderstanding. Here it's only a single trust source (TPM *or* TEE) is initialized and only that trust source would be active at runtime. And trusted_key_ops would be initialized to the first trust source whose initialization is successful (see check: "if (!ret)"). > After patch 2/4, the last trusted source initialized is TEE. If the > intention is to limit it to either TPM or TEE, then trusted_key_ops > should have a default value, which could be overwritten at runtime. > That would address Luke Hind's concerns of making the decision at > compile time. I think traversing the trust source list with the initial value being TPM would be default value. > > trusted_key_ops should be defined as __ro_after_init, like is currently > done for other LSM structures. Sure, will do. > > > + > > + /* > > + * 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) > > +{ > > + trusted_key_ops->exit(); > > If the intention is really to support both TPM and TEE trusted keys at > the same time, as James suggested, then the same "for" loop as in > init_trusted() is needed here and probably elsewhere. Current intention is to only support a single trust source (TPM or TEE) at runtime. But in future if there are use-cases then framework can be extended to support multiple trust sources at runtime as well. -Sumit > > thanks, > > Mimi >
On Wed, 2020-10-21 at 11:16 +0530, Sumit Garg wrote: > Thanks Mimi for your comments. > > On Wed, 21 Oct 2020 at 08:51, Mimi Zohar <zohar@linux.ibm.com> wrote: > > > > On Wed, 2020-10-07 at 15:37 +0530, Sumit Garg wrote: > > > > > +/* > > > + * 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 __init init_trusted(void) > > > +{ > > > + 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; > > > + > > > + trusted_key_ops = trusted_key_sources[i].ops; > > > + > > > + ret = trusted_key_ops->init(); > > > + if (!ret) > > > + break; > > > + } > > > > In the case when the module paramater isn't specified and both TPM and > > TEE are enabled, trusted_key_ops is set to the last source initialized. > > I guess there is some misunderstanding. Here it's only a single trust > source (TPM *or* TEE) is initialized and only that trust source would > be active at runtime. And trusted_key_ops would be initialized to the > first trust source whose initialization is successful (see check: "if > (!ret)"). My mistake. > > > After patch 2/4, the last trusted source initialized is TEE. If the > > intention is to limit it to either TPM or TEE, then trusted_key_ops > > should have a default value, which could be overwritten at runtime. > > That would address Luke Hind's concerns of making the decision at > > compile time. > > I think traversing the trust source list with the initial value being > TPM would be default value. Agreed > > > > > trusted_key_ops should be defined as __ro_after_init, like is currently > > done for other LSM structures. > > Sure, will do. Thanks > > > > > > + > > > + /* > > > + * 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) > > > +{ > > > + trusted_key_ops->exit(); > > > > If the intention is really to support both TPM and TEE trusted keys at > > the same time, as James suggested, then the same "for" loop as in > > init_trusted() is needed here and probably elsewhere. > > Current intention is to only support a single trust source (TPM or > TEE) at runtime. But in future if there are use-cases then framework > can be extended to support multiple trust sources at runtime as well. Ok, the last sentence of the patch description, "Also, add a module parameter in order to select a particular trust source in case a platform support multiple trust sources.", needs to be expanded to: - indicate only one trust source at a time is supported - indicate the default, if the module_param is not specified I would also change the word from "add" to "define". The new "source" module parameter needs to be added to the admin-guide/kernel-parameters documentation. thanks, Mimi
On Wed, 21 Oct 2020 at 17:55, Mimi Zohar <zohar@linux.ibm.com> wrote: > > On Wed, 2020-10-21 at 11:16 +0530, Sumit Garg wrote: > > Thanks Mimi for your comments. > > > > On Wed, 21 Oct 2020 at 08:51, Mimi Zohar <zohar@linux.ibm.com> wrote: > > > > > > On Wed, 2020-10-07 at 15:37 +0530, Sumit Garg wrote: > > > > > > > +/* > > > > + * 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 __init init_trusted(void) > > > > +{ > > > > + 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; > > > > + > > > > + trusted_key_ops = trusted_key_sources[i].ops; > > > > + > > > > + ret = trusted_key_ops->init(); > > > > + if (!ret) > > > > + break; > > > > + } > > > > > > In the case when the module paramater isn't specified and both TPM and > > > TEE are enabled, trusted_key_ops is set to the last source initialized. > > > > I guess there is some misunderstanding. Here it's only a single trust > > source (TPM *or* TEE) is initialized and only that trust source would > > be active at runtime. And trusted_key_ops would be initialized to the > > first trust source whose initialization is successful (see check: "if > > (!ret)"). > > My mistake. > > > > > > After patch 2/4, the last trusted source initialized is TEE. If the > > > intention is to limit it to either TPM or TEE, then trusted_key_ops > > > should have a default value, which could be overwritten at runtime. > > > That would address Luke Hind's concerns of making the decision at > > > compile time. > > > > I think traversing the trust source list with the initial value being > > TPM would be default value. > > Agreed > > > > > > > > trusted_key_ops should be defined as __ro_after_init, like is currently > > > done for other LSM structures. > > > > Sure, will do. > > Thanks > > > > > > > > > + > > > > + /* > > > > + * 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) > > > > +{ > > > > + trusted_key_ops->exit(); > > > > > > If the intention is really to support both TPM and TEE trusted keys at > > > the same time, as James suggested, then the same "for" loop as in > > > init_trusted() is needed here and probably elsewhere. > > > > Current intention is to only support a single trust source (TPM or > > TEE) at runtime. But in future if there are use-cases then framework > > can be extended to support multiple trust sources at runtime as well. > > Ok, the last sentence of the patch description, "Also, add a module > parameter in order to select a particular trust source in case a > platform support multiple trust sources.", needs to be expanded to: > - indicate only one trust source at a time is supported > - indicate the default, if the module_param is not specified > Sure, I will expand that. > I would also change the word from "add" to "define". Ack. > The new "source" > module parameter needs to be added to the admin-guide/kernel-parameters > documentation. Okay, will update documentation as well. -Sumit > > thanks, > > Mimi > >
diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h index a94c03a..a566451 100644 --- a/include/keys/trusted-type.h +++ b/include/keys/trusted-type.h @@ -40,6 +40,53 @@ 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; + + /* Initialize key interface. */ + int (*init)(void); + + /* Seal a key. */ + int (*seal)(struct trusted_key_payload *p, char *datablob); + + /* Unseal a key. */ + int (*unseal)(struct trusted_key_payload *p, char *datablob); + + /* Get a randomized key. */ + int (*get_random)(unsigned char *key, size_t key_len); + + /* Exit key interface. */ + void (*exit)(void); +}; + +struct trusted_key_source { + char *name; + struct trusted_key_ops *ops; +}; + extern struct key_type key_type_trusted; +#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 a56d8e1..fb3280a 100644 --- a/include/keys/trusted_tpm.h +++ b/include/keys/trusted_tpm.h @@ -16,6 +16,8 @@ #define LOAD32N(buffer, offset) (*(uint32_t *)&buffer[offset]) #define LOAD16(buffer, offset) (ntohs(*(uint16_t *)&buffer[offset])) +extern struct trusted_key_ops tpm_trusted_key_ops; + struct osapsess { uint32_t handle; unsigned char secret[SHA1_DIGEST_SIZE]; @@ -60,17 +62,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, @@ -96,10 +87,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 7b73ceb..49e3bcf 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_core.o trusted-y += trusted_tpm1.o trusted-y += trusted_tpm2.o diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trusted-keys/trusted_core.c new file mode 100644 index 0000000..71a5e27 --- /dev/null +++ b/security/keys/trusted-keys/trusted_core.c @@ -0,0 +1,330 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2010 IBM Corporation + * Copyright (c) 2019-2020, Linaro Limited + * + * See Documentation/security/keys/trusted-encrypted.rst + */ + +#include <keys/user-type.h> +#include <keys/trusted-type.h> +#include <keys/trusted_tpm.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 char *trusted_key_source; +module_param_named(source, trusted_key_source, charp, 0); +MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)"); + +static struct trusted_key_source trusted_key_sources[] = { +#if defined(CONFIG_TCG_TPM) + { "tpm", &tpm_trusted_key_ops }, +#endif +}; +static struct trusted_key_ops *trusted_key_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 = trusted_key_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 = trusted_key_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 = trusted_key_ops->get_random(payload->key, key_len); + if (ret != key_len) { + pr_info("trusted_key: key_create failed (%d)\n", ret); + goto out; + } + + ret = trusted_key_ops->seal(payload, datablob); + if (ret < 0) + pr_info("trusted_key: key_seal failed (%d)\n", ret); + break; + default: + ret = -EINVAL; + } +out: + kfree_sensitive(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; + 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; + 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 = trusted_key_ops->seal(new_p, datablob); + if (ret < 0) { + pr_info("trusted_key: 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(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 __init init_trusted(void) +{ + 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; + + trusted_key_ops = trusted_key_sources[i].ops; + + ret = trusted_key_ops->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) +{ + trusted_key_ops->exit(); +} + +late_initcall(init_trusted); +module_exit(cleanup_trusted); + +MODULE_LICENSE("GPL"); diff --git a/security/keys/trusted-keys/trusted_tpm1.c b/security/keys/trusted-keys/trusted_tpm1.c index b9fe02e..1c5df77 100644 --- a/security/keys/trusted-keys/trusted_tpm1.c +++ b/security/keys/trusted-keys/trusted_tpm1.c @@ -1,29 +1,22 @@ // SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2010 IBM Corporation - * - * Author: - * David Safford <safford@us.ibm.com> + * Copyright (c) 2019-2020, Linaro Limited * * 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> @@ -703,7 +696,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, @@ -712,9 +704,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"}, @@ -841,71 +830,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; @@ -926,248 +850,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_trusted_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 = tpm2_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 = tpm2_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 = tpm2_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: - kfree_sensitive(datablob); kfree_sensitive(options); - 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) +static int tpm_trusted_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; - kfree_sensitive(new_p); + ret = getoptions(datablob, p, options); + if (ret < 0) goto out; - } + dump_options(options); - if (!new_o->keyhandle) { + if (!options->keyhandle) { 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); + if (tpm2) + ret = tpm2_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); - kfree_sensitive(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); - kfree_sensitive(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: - kfree_sensitive(datablob); - kfree_sensitive(new_o); + kfree_sensitive(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 *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) +static int tpm_trusted_get_random(unsigned char *key, size_t key_len) { - kfree_sensitive(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) @@ -1182,14 +957,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; @@ -1217,16 +992,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) @@ -1247,7 +1019,7 @@ static int __init init_trusted(void) return ret; } -static void __exit cleanup_trusted(void) +static void __exit exit_tpm_trusted(void) { if (chip) { put_device(&chip->dev); @@ -1257,7 +1029,11 @@ 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_trusted_seal, + .unseal = tpm_trusted_unseal, + .get_random = tpm_trusted_get_random, + .exit = exit_tpm_trusted, +};
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 trusted keys support in case platform doesn't posses a TPM device. Add a generic trusted keys framework where underlying implementations can be easily plugged in. Create struct trusted_key_ops to achieve this, which contains necessary functions of a backend. Also, add a module parameter in order to select a particular trust source in case a platform support multiple trust sources. Suggested-by: Jarkko Sakkinen <jarkko.sakkinen@linux.intel.com> Signed-off-by: Sumit Garg <sumit.garg@linaro.org> --- include/keys/trusted-type.h | 47 +++++ include/keys/trusted_tpm.h | 17 +- security/keys/trusted-keys/Makefile | 1 + security/keys/trusted-keys/trusted_core.c | 330 +++++++++++++++++++++++++++++ security/keys/trusted-keys/trusted_tpm1.c | 336 +++++------------------------- 5 files changed, 436 insertions(+), 295 deletions(-) create mode 100644 security/keys/trusted-keys/trusted_core.c