On Tue, Jun 02, 2020 at 07:48:22PM +0530, Sumit Garg wrote:
> diff --git a/security/keys/Kconfig b/security/keys/Kconfig
> index 47c0415..22632c6 100644
> --- a/security/keys/Kconfig
> +++ b/security/keys/Kconfig
> @@ -72,17 +72,26 @@ config BIG_KEYS
>
> config TRUSTED_KEYS
> tristate "TRUSTED KEYS"
> - depends on KEYS && TCG_TPM
> + depends on KEYS
> + 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 (TPM or TEE). Userspace will
> + only ever see encrypted blobs.
> +
> + If you are unsure as to whether this is required, answer N.
> +
> +config TRUSTED_TPM
TRUSTED_TPM_KEYS
> + bool "TPM based TRUSTED KEYS"
> + depends on TRUSTED_KEYS && TCG_TPM
> select CRYPTO
> select CRYPTO_HMAC
> select CRYPTO_SHA1
> select CRYPTO_HASH_INFO
> help
> - This option provides support for creating, sealing, and unsealing
> - keys in the kernel. Trusted keys are random number symmetric keys,
> - generated and RSA-sealed by the TPM. The TPM only unseals the keys,
> - if the boot PCRs and other criteria match. Userspace will only ever
> - see encrypted blobs.
> + This option provides support for TPM based trusted keys where TPM acts
> + as the trust source. The keys are RSA-sealed by the TPM and it only
> + unseals the keys, if the boot PCRs and other criteria match.
>
> If you are unsure as to whether this is required, answer N.
>
> diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-keys/Makefile
> index 7b73ceb..03c3ad4 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_tpm1.o
> -trusted-y += trusted_tpm2.o
> +trusted-y += trusted_core.o
> +trusted-$(CONFIG_TRUSTED_TPM) += trusted_tpm1.o
> +trusted-$(CONFIG_TRUSTED_TPM) += 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..3d07d27
> --- /dev/null
> +++ b/security/keys/trusted-keys/trusted_core.c
> @@ -0,0 +1,319 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2010 IBM Corporation
> + * Copyright (c) 2019, Linaro Limited
> + *
> + * Author:
> + * David Safford <safford@xxxxxxxxxx>
> + * Added generic trusted key framework: Sumit Garg <sumit.garg@xxxxxxxxxx>
Rather remove David's because
1. Git log gives a verifiable and exact log of authority.
2. David's commit was done post-epoch of Git.
> + *
> + * 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>
> +
> +#if defined(CONFIG_TRUSTED_TPM)
> +static struct trusted_key_ops *trusted_key_ops = &tpm_trusted_key_ops;
> +#else
> +static struct trusted_key_ops *trusted_key_ops;
> +#endif
You should just have
extern 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:
> + 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 = trusted_key_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 *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)
> +{
> + 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 ret;
> +
> + /*
> + * encrypted_keys.ko depends on successful load of this module even if
> + * trusted key implementation is not found.
> + */
> + if (!trusted_key_ops)
> + return 0;
> +
> + ret = trusted_key_ops->init();
> + 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 8001ab0..e378b27 100644
> --- a/security/keys/trusted-keys/trusted_tpm1.c
> +++ b/security/keys/trusted-keys/trusted_tpm1.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@xxxxxxxxxx>
> + * Switch to generic trusted key framework: Sumit Garg <sumit.garg@xxxxxxxxxx>
> *
> * 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 +700,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 +708,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 +834,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 +854,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:
> - 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)
> +static int tpm_trusted_unseal(struct trusted_key_payload *p, char *datablob)
> {
> - 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;
> - 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 = 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);
> - 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 *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)
> +int tpm_trusted_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)
> @@ -1182,14 +961,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 +996,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 +1023,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 +1033,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_trusted_seal,
> + .unseal = tpm_trusted_unseal,
> + .get_random = tpm_trusted_get_random,
> + .exit = exit_tpm_trusted,
> +};
> +EXPORT_SYMBOL_GPL(tpm_trusted_key_ops); > --
Rename this as trusted_key_ops and remove EXPORT_SYMBOL_GPL()
> 2.7.4
>
/Jarkko
