* [PATCH v5 1/5] KEYS: trusted: allow use of TEE as backend without TCG_TPM support
2022-02-22 19:58 [PATCH v5 0/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
@ 2022-02-22 19:58 ` Ahmad Fatoum
2022-02-22 19:58 ` [PATCH v5 2/5] KEYS: trusted: allow users to use kernel RNG for key material Ahmad Fatoum
` (3 subsequent siblings)
4 siblings, 0 replies; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-22 19:58 UTC (permalink / raw)
To: Jarkko Sakkinen, James Morris, Serge E. Hallyn, James Bottomley,
Mimi Zohar, Sumit Garg, David Howells, Herbert Xu,
David S. Miller
Cc: kernel, Andreas Rammhold, Tim Harvey, Ahmad Fatoum, David Gstir,
Richard Weinberger, Matthias Schiffer, Pankaj Gupta, keyrings,
linux-crypto, linux-kernel, linux-security-module,
linux-integrity
With recent rework, trusted keys are no longer limited to TPM as trust
source. The Kconfig symbol is unchanged however leading to a few issues:
- TCG_TPM is required, even if only TEE is to be used
- Enabling TCG_TPM, but excluding it from available trusted sources
is not possible
- TEE=m && TRUSTED_KEYS=y will lead to TEE support being silently
dropped, which is not the best user experience
Remedy these issues by introducing two new boolean Kconfig symbols:
TRUSTED_KEYS_TPM and TRUSTED_KEYS_TEE with the appropriate
dependencies.
Any code depending on the TPM trusted key backend or symbols exported
by it will now need to explicitly state that it
depends on TRUSTED_KEYS && TRUSTED_KEYS_TPM
The latter to ensure the dependency is built and the former to ensure
it's reachable for module builds. This currently only affects
CONFIG_ASYMMETRIC_TPM_KEY_SUBTYPE, so it's fixed up here as well.
Reviewed-by: Sumit Garg <sumit.garg@linaro.org>
Reviewed-by: Jarkko Sakkinen <jarkko@kernel.org>
Tested-By: Andreas Rammhold <andreas@rammhold.de>
Tested-By: Tim Harvey <tharvey@gateworks.com>
Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
v4 -> v5:
- collected Jarkko's Reviewed-by
v3 -> v4:
- rebased on top of Andreas' regression fix and pulled it back
into series
v2 -> v3:
- factored this patch out as a fix for backporting
v1 -> v2:
- Move rest of TPM-related selects from TRUSTED_KEYS to
TRUSTED_KEYS_TPM (Sumit)
- Remove left-over line in Makefile (Sumit)
- added Fixes: tag
- adjust commit message to reference the regression reported
by Andreas
- have ASYMMETRIC_TPM_KEY_SUBTYPE depend on TRUSTED_KEYS_TPM,
because it references global symbols that are exported
by the trusted key TPM backend.
[1]: https://lore.kernel.org/linux-integrity/f8285eb0135ba30c9d846cf9dd395d1f5f8b1efc.1624364386.git-series.a.fatoum@pengutronix.de/
[2]: https://lore.kernel.org/linux-integrity/20210719091335.vwfebcpkf4pag3wm@wrt/T/#t
To: Jarkko Sakkinen <jarkko@kernel.org>
To: James Morris <jmorris@namei.org>
To: "Serge E. Hallyn" <serge@hallyn.com>
To: James Bottomley <jejb@linux.ibm.com>
To: Mimi Zohar <zohar@linux.ibm.com>
To: Sumit Garg <sumit.garg@linaro.org>
To: David Howells <dhowells@redhat.com>
To: Herbert Xu <herbert@gondor.apana.org.au>
To: "David S. Miller" <davem@davemloft.net>
Cc: David Gstir <david@sigma-star.at>
Cc: Richard Weinberger <richard@nod.at>
Cc: Tim Harvey <tharvey@gateworks.com>
Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
Cc: keyrings@vger.kernel.org
Cc: linux-crypto@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-security-module@vger.kernel.org
Cc: linux-integrity@vger.kernel.org
---
crypto/asymmetric_keys/Kconfig | 2 +-
security/keys/Kconfig | 18 ++++++--------
security/keys/trusted-keys/Kconfig | 29 +++++++++++++++++++++++
security/keys/trusted-keys/Makefile | 8 +++----
security/keys/trusted-keys/trusted_core.c | 4 ++--
5 files changed, 43 insertions(+), 18 deletions(-)
create mode 100644 security/keys/trusted-keys/Kconfig
diff --git a/crypto/asymmetric_keys/Kconfig b/crypto/asymmetric_keys/Kconfig
index 1f1f004dc757..8886eddbf881 100644
--- a/crypto/asymmetric_keys/Kconfig
+++ b/crypto/asymmetric_keys/Kconfig
@@ -25,7 +25,7 @@ config ASYMMETRIC_PUBLIC_KEY_SUBTYPE
config ASYMMETRIC_TPM_KEY_SUBTYPE
tristate "Asymmetric TPM backed private key subtype"
depends on TCG_TPM
- depends on TRUSTED_KEYS
+ depends on TRUSTED_KEYS && TRUSTED_KEYS_TPM
select CRYPTO_HMAC
select CRYPTO_SHA1
select CRYPTO_HASH_INFO
diff --git a/security/keys/Kconfig b/security/keys/Kconfig
index 969122c7b92f..826cd0904f9a 100644
--- a/security/keys/Kconfig
+++ b/security/keys/Kconfig
@@ -70,23 +70,19 @@ config BIG_KEYS
config TRUSTED_KEYS
tristate "TRUSTED KEYS"
- depends on KEYS && TCG_TPM
- select CRYPTO
- select CRYPTO_HMAC
- select CRYPTO_SHA1
- select CRYPTO_HASH_INFO
- select ASN1_ENCODER
- select OID_REGISTRY
- select ASN1
+ 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 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.
+ generated and sealed by a trust source selected at kernel boot-time.
+ Userspace will only ever see encrypted blobs.
If you are unsure as to whether this is required, answer N.
+if TRUSTED_KEYS
+source "security/keys/trusted-keys/Kconfig"
+endif
+
config ENCRYPTED_KEYS
tristate "ENCRYPTED KEYS"
depends on KEYS
diff --git a/security/keys/trusted-keys/Kconfig b/security/keys/trusted-keys/Kconfig
new file mode 100644
index 000000000000..fc4abd581abb
--- /dev/null
+++ b/security/keys/trusted-keys/Kconfig
@@ -0,0 +1,29 @@
+config TRUSTED_KEYS_TPM
+ bool "TPM-based trusted keys"
+ depends on TCG_TPM >= TRUSTED_KEYS
+ default y
+ select CRYPTO
+ select CRYPTO_HMAC
+ select CRYPTO_SHA1
+ select CRYPTO_HASH_INFO
+ select ASN1_ENCODER
+ select OID_REGISTRY
+ select ASN1
+ help
+ Enable use of the Trusted Platform Module (TPM) as trusted key
+ backend. Trusted keys are random number symmetric keys,
+ which will be generated and RSA-sealed by the TPM.
+ The TPM only unseals the keys, if the boot PCRs and other
+ criteria match.
+
+config TRUSTED_KEYS_TEE
+ bool "TEE-based trusted keys"
+ depends on TEE >= TRUSTED_KEYS
+ default y
+ help
+ Enable use of the Trusted Execution Environment (TEE) as trusted
+ key backend.
+
+if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
+comment "No trust source selected!"
+endif
diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-keys/Makefile
index feb8b6c3cc79..2e2371eae4d5 100644
--- a/security/keys/trusted-keys/Makefile
+++ b/security/keys/trusted-keys/Makefile
@@ -5,10 +5,10 @@
obj-$(CONFIG_TRUSTED_KEYS) += trusted.o
trusted-y += trusted_core.o
-trusted-y += trusted_tpm1.o
+trusted-$(CONFIG_TRUSTED_KEYS_TPM) += trusted_tpm1.o
$(obj)/trusted_tpm2.o: $(obj)/tpm2key.asn1.h
-trusted-y += trusted_tpm2.o
-trusted-y += tpm2key.asn1.o
+trusted-$(CONFIG_TRUSTED_KEYS_TPM) += trusted_tpm2.o
+trusted-$(CONFIG_TRUSTED_KEYS_TPM) += tpm2key.asn1.o
-trusted-$(CONFIG_TEE) += trusted_tee.o
+trusted-$(CONFIG_TRUSTED_KEYS_TEE) += trusted_tee.o
diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trusted-keys/trusted_core.c
index 9b9d3ef79cbe..7cdbd16aed30 100644
--- a/security/keys/trusted-keys/trusted_core.c
+++ b/security/keys/trusted-keys/trusted_core.c
@@ -27,10 +27,10 @@ module_param_named(source, trusted_key_source, charp, 0);
MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
static const struct trusted_key_source trusted_key_sources[] = {
-#if IS_REACHABLE(CONFIG_TCG_TPM)
+#if defined(CONFIG_TRUSTED_KEYS_TPM)
{ "tpm", &trusted_key_tpm_ops },
#endif
-#if IS_REACHABLE(CONFIG_TEE)
+#if defined(CONFIG_TRUSTED_KEYS_TEE)
{ "tee", &trusted_key_tee_ops },
#endif
};
--
2.30.2
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH v5 2/5] KEYS: trusted: allow users to use kernel RNG for key material
2022-02-22 19:58 [PATCH v5 0/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
2022-02-22 19:58 ` [PATCH v5 1/5] KEYS: trusted: allow use of TEE as backend without TCG_TPM support Ahmad Fatoum
@ 2022-02-22 19:58 ` Ahmad Fatoum
2022-02-23 15:42 ` Jarkko Sakkinen
2022-02-22 19:58 ` [PATCH v5 3/5] KEYS: trusted: allow trust sources " Ahmad Fatoum
` (2 subsequent siblings)
4 siblings, 1 reply; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-22 19:58 UTC (permalink / raw)
To: James Bottomley, Jarkko Sakkinen, Mimi Zohar, David Howells
Cc: kernel, Sumit Garg, David Gstir, Pankaj Gupta, Ahmad Fatoum,
James Morris, Serge E. Hallyn, Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, Jan Luebbe,
Eric Biggers, Richard Weinberger, Franck LENORMAND, Tim Harvey,
Matthias Schiffer, keyrings, linux-crypto, linux-integrity,
linux-kernel, linux-security-module
The two existing trusted key sources don't make use of the kernel RNG,
but instead let the hardware doing the sealing/unsealing also
generate the random key material. However, users may want to place
less trust into the quality of the trust source's random number
generator and instead use the kernel entropy pool, which can be
seeded from multiple entropy sources.
Make this possible by adding a new trusted.kernel_rng parameter,
that will force use of the kernel RNG. In its absence, it's up
to the trust source to decide, which random numbers to use,
maintaining the existing behavior.
Suggested-by: Jarkko Sakkinen <jarkko@kernel.org>
Acked-by: Sumit Garg <sumit.garg@linaro.org>
Reviewed-by: David Gstir <david@sigma-star.at>
Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
To: James Bottomley <jejb@linux.ibm.com>
To: Jarkko Sakkinen <jarkko@kernel.org>
To: Mimi Zohar <zohar@linux.ibm.com>
To: David Howells <dhowells@redhat.com>
Cc: James Morris <jmorris@namei.org>
Cc: "Serge E. Hallyn" <serge@hallyn.com>
Cc: "Horia Geantă" <horia.geanta@nxp.com>
Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Jan Luebbe <j.luebbe@pengutronix.de>
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: David Gstir <david@sigma-star.at>
Cc: Richard Weinberger <richard@nod.at>
Cc: Franck LENORMAND <franck.lenormand@nxp.com>
Cc: Sumit Garg <sumit.garg@linaro.org>
Cc: Tim Harvey <tharvey@gateworks.com>
Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
Cc: keyrings@vger.kernel.org
Cc: linux-crypto@vger.kernel.org
Cc: linux-integrity@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-security-module@vger.kernel.org
---
.../admin-guide/kernel-parameters.txt | 10 ++++++
.../security/keys/trusted-encrypted.rst | 20 ++++++-----
security/keys/trusted-keys/trusted_core.c | 35 ++++++++++++++++++-
3 files changed, 56 insertions(+), 9 deletions(-)
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index f5a27f067db9..844c883ca9d8 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -5880,6 +5880,16 @@
first trust source as a backend which is initialized
successfully during iteration.
+ trusted.rng= [KEYS]
+ Format: <string>
+ The RNG used to generate key material for trusted keys.
+ Can be one of:
+ - "kernel"
+ - the same value as trusted.source: "tpm" or "tee"
+ - "default"
+ If not specified, "default" is used. In this case,
+ the RNG's choice is left to each individual trust source.
+
tsc= Disable clocksource stability checks for TSC.
Format: <string>
[x86] reliable: mark tsc clocksource as reliable, this
diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentation/security/keys/trusted-encrypted.rst
index 80d5a5af62a1..99cf34d7c025 100644
--- a/Documentation/security/keys/trusted-encrypted.rst
+++ b/Documentation/security/keys/trusted-encrypted.rst
@@ -87,22 +87,26 @@ Key Generation
Trusted Keys
------------
-New keys are created from random numbers generated in the trust source. They
-are encrypted/decrypted using a child key in the storage key hierarchy.
-Encryption and decryption of the child key must be protected by a strong
-access control policy within the trust source.
+New keys are created from random numbers. They are encrypted/decrypted using
+a child key in the storage key hierarchy. Encryption and decryption of the
+child key must be protected by a strong access control policy within the
+trust source. The random number generator in use differs according to the
+selected trust source:
- * TPM (hardware device) based RNG
+ * TPM: hardware device based RNG
- Strength of random numbers may vary from one device manufacturer to
- another.
+ Keys are generated within the TPM. Strength of random numbers may vary
+ from one device manufacturer to another.
- * TEE (OP-TEE based on Arm TrustZone) based RNG
+ * TEE: OP-TEE based on Arm TrustZone based RNG
RNG is customizable as per platform needs. It can either be direct output
from platform specific hardware RNG or a software based Fortuna CSPRNG
which can be seeded via multiple entropy sources.
+Users may override this by specifying ``trusted.rng=kernel`` on the kernel
+command-line to override the used RNG with the kernel's random number pool.
+
Encrypted Keys
--------------
diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trusted-keys/trusted_core.c
index 7cdbd16aed30..9235fb7d0ec9 100644
--- a/security/keys/trusted-keys/trusted_core.c
+++ b/security/keys/trusted-keys/trusted_core.c
@@ -16,12 +16,17 @@
#include <linux/key-type.h>
#include <linux/module.h>
#include <linux/parser.h>
+#include <linux/random.h>
#include <linux/rcupdate.h>
#include <linux/slab.h>
#include <linux/static_call.h>
#include <linux/string.h>
#include <linux/uaccess.h>
+static char *trusted_rng = "default";
+module_param_named(rng, trusted_rng, charp, 0);
+MODULE_PARM_DESC(rng, "Select trusted key RNG");
+
static char *trusted_key_source;
module_param_named(source, trusted_key_source, charp, 0);
MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
@@ -312,8 +317,14 @@ struct key_type key_type_trusted = {
};
EXPORT_SYMBOL_GPL(key_type_trusted);
+static int kernel_get_random(unsigned char *key, size_t key_len)
+{
+ return get_random_bytes_wait(key, key_len) ?: key_len;
+}
+
static int __init init_trusted(void)
{
+ int (*get_random)(unsigned char *key, size_t key_len);
int i, ret = 0;
for (i = 0; i < ARRAY_SIZE(trusted_key_sources); i++) {
@@ -322,6 +333,28 @@ static int __init init_trusted(void)
strlen(trusted_key_sources[i].name)))
continue;
+ /*
+ * We always support trusted.rng="kernel" and "default" as
+ * well as trusted.rng=$trusted.source if the trust source
+ * defines its own get_random callback.
+ */
+ get_random = trusted_key_sources[i].ops->get_random;
+ if (trusted_rng && strcmp(trusted_rng, "default")) {
+ if (!strcmp(trusted_rng, "kernel")) {
+ get_random = kernel_get_random;
+ } else if (strcmp(trusted_rng, trusted_key_sources[i].name) ||
+ !get_random) {
+ pr_warn("Unsupported RNG. Supported: kernel");
+ if (get_random)
+ pr_cont(", %s", trusted_key_sources[i].name);
+ pr_cont(", default\n");
+ return -EINVAL;
+ }
+ }
+
+ if (!get_random)
+ get_random = kernel_get_random;
+
static_call_update(trusted_key_init,
trusted_key_sources[i].ops->init);
static_call_update(trusted_key_seal,
@@ -329,7 +362,7 @@ static int __init init_trusted(void)
static_call_update(trusted_key_unseal,
trusted_key_sources[i].ops->unseal);
static_call_update(trusted_key_get_random,
- trusted_key_sources[i].ops->get_random);
+ get_random);
static_call_update(trusted_key_exit,
trusted_key_sources[i].ops->exit);
migratable = trusted_key_sources[i].ops->migratable;
--
2.30.2
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 2/5] KEYS: trusted: allow users to use kernel RNG for key material
2022-02-22 19:58 ` [PATCH v5 2/5] KEYS: trusted: allow users to use kernel RNG for key material Ahmad Fatoum
@ 2022-02-23 15:42 ` Jarkko Sakkinen
0 siblings, 0 replies; 19+ messages in thread
From: Jarkko Sakkinen @ 2022-02-23 15:42 UTC (permalink / raw)
To: Ahmad Fatoum
Cc: James Bottomley, Mimi Zohar, David Howells, kernel, Sumit Garg,
David Gstir, Pankaj Gupta, James Morris, Serge E. Hallyn,
Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, Jan Luebbe,
Eric Biggers, Richard Weinberger, Franck LENORMAND, Tim Harvey,
Matthias Schiffer, keyrings, linux-crypto, linux-integrity,
linux-kernel, linux-security-module
On Tue, Feb 22, 2022 at 08:58:16PM +0100, Ahmad Fatoum wrote:
> The two existing trusted key sources don't make use of the kernel RNG,
> but instead let the hardware doing the sealing/unsealing also
> generate the random key material. However, users may want to place
> less trust into the quality of the trust source's random number
> generator and instead use the kernel entropy pool, which can be
> seeded from multiple entropy sources.
>
> Make this possible by adding a new trusted.kernel_rng parameter,
> that will force use of the kernel RNG. In its absence, it's up
> to the trust source to decide, which random numbers to use,
> maintaining the existing behavior.
>
> Suggested-by: Jarkko Sakkinen <jarkko@kernel.org>
> Acked-by: Sumit Garg <sumit.garg@linaro.org>
> Reviewed-by: David Gstir <david@sigma-star.at>
> Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> ---
> To: James Bottomley <jejb@linux.ibm.com>
> To: Jarkko Sakkinen <jarkko@kernel.org>
> To: Mimi Zohar <zohar@linux.ibm.com>
> To: David Howells <dhowells@redhat.com>
> Cc: James Morris <jmorris@namei.org>
> Cc: "Serge E. Hallyn" <serge@hallyn.com>
> Cc: "Horia Geantă" <horia.geanta@nxp.com>
> Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> Cc: Herbert Xu <herbert@gondor.apana.org.au>
> Cc: "David S. Miller" <davem@davemloft.net>
> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> Cc: Eric Biggers <ebiggers@kernel.org>
> Cc: David Gstir <david@sigma-star.at>
> Cc: Richard Weinberger <richard@nod.at>
> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> Cc: Sumit Garg <sumit.garg@linaro.org>
> Cc: Tim Harvey <tharvey@gateworks.com>
> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> Cc: keyrings@vger.kernel.org
> Cc: linux-crypto@vger.kernel.org
> Cc: linux-integrity@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> Cc: linux-security-module@vger.kernel.org
> ---
> .../admin-guide/kernel-parameters.txt | 10 ++++++
> .../security/keys/trusted-encrypted.rst | 20 ++++++-----
> security/keys/trusted-keys/trusted_core.c | 35 ++++++++++++++++++-
> 3 files changed, 56 insertions(+), 9 deletions(-)
>
> diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
> index f5a27f067db9..844c883ca9d8 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -5880,6 +5880,16 @@
> first trust source as a backend which is initialized
> successfully during iteration.
>
> + trusted.rng= [KEYS]
> + Format: <string>
> + The RNG used to generate key material for trusted keys.
> + Can be one of:
> + - "kernel"
> + - the same value as trusted.source: "tpm" or "tee"
> + - "default"
> + If not specified, "default" is used. In this case,
> + the RNG's choice is left to each individual trust source.
> +
> tsc= Disable clocksource stability checks for TSC.
> Format: <string>
> [x86] reliable: mark tsc clocksource as reliable, this
> diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentation/security/keys/trusted-encrypted.rst
> index 80d5a5af62a1..99cf34d7c025 100644
> --- a/Documentation/security/keys/trusted-encrypted.rst
> +++ b/Documentation/security/keys/trusted-encrypted.rst
> @@ -87,22 +87,26 @@ Key Generation
> Trusted Keys
> ------------
>
> -New keys are created from random numbers generated in the trust source. They
> -are encrypted/decrypted using a child key in the storage key hierarchy.
> -Encryption and decryption of the child key must be protected by a strong
> -access control policy within the trust source.
> +New keys are created from random numbers. They are encrypted/decrypted using
> +a child key in the storage key hierarchy. Encryption and decryption of the
> +child key must be protected by a strong access control policy within the
> +trust source. The random number generator in use differs according to the
> +selected trust source:
>
> - * TPM (hardware device) based RNG
> + * TPM: hardware device based RNG
>
> - Strength of random numbers may vary from one device manufacturer to
> - another.
> + Keys are generated within the TPM. Strength of random numbers may vary
> + from one device manufacturer to another.
>
> - * TEE (OP-TEE based on Arm TrustZone) based RNG
> + * TEE: OP-TEE based on Arm TrustZone based RNG
>
> RNG is customizable as per platform needs. It can either be direct output
> from platform specific hardware RNG or a software based Fortuna CSPRNG
> which can be seeded via multiple entropy sources.
>
> +Users may override this by specifying ``trusted.rng=kernel`` on the kernel
> +command-line to override the used RNG with the kernel's random number pool.
> +
> Encrypted Keys
> --------------
>
> diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trusted-keys/trusted_core.c
> index 7cdbd16aed30..9235fb7d0ec9 100644
> --- a/security/keys/trusted-keys/trusted_core.c
> +++ b/security/keys/trusted-keys/trusted_core.c
> @@ -16,12 +16,17 @@
> #include <linux/key-type.h>
> #include <linux/module.h>
> #include <linux/parser.h>
> +#include <linux/random.h>
> #include <linux/rcupdate.h>
> #include <linux/slab.h>
> #include <linux/static_call.h>
> #include <linux/string.h>
> #include <linux/uaccess.h>
>
> +static char *trusted_rng = "default";
> +module_param_named(rng, trusted_rng, charp, 0);
> +MODULE_PARM_DESC(rng, "Select trusted key RNG");
> +
> static char *trusted_key_source;
> module_param_named(source, trusted_key_source, charp, 0);
> MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
> @@ -312,8 +317,14 @@ struct key_type key_type_trusted = {
> };
> EXPORT_SYMBOL_GPL(key_type_trusted);
>
> +static int kernel_get_random(unsigned char *key, size_t key_len)
> +{
> + return get_random_bytes_wait(key, key_len) ?: key_len;
> +}
> +
> static int __init init_trusted(void)
> {
> + int (*get_random)(unsigned char *key, size_t key_len);
> int i, ret = 0;
>
> for (i = 0; i < ARRAY_SIZE(trusted_key_sources); i++) {
> @@ -322,6 +333,28 @@ static int __init init_trusted(void)
> strlen(trusted_key_sources[i].name)))
> continue;
>
> + /*
> + * We always support trusted.rng="kernel" and "default" as
> + * well as trusted.rng=$trusted.source if the trust source
> + * defines its own get_random callback.
> + */
> + get_random = trusted_key_sources[i].ops->get_random;
> + if (trusted_rng && strcmp(trusted_rng, "default")) {
> + if (!strcmp(trusted_rng, "kernel")) {
> + get_random = kernel_get_random;
> + } else if (strcmp(trusted_rng, trusted_key_sources[i].name) ||
> + !get_random) {
> + pr_warn("Unsupported RNG. Supported: kernel");
> + if (get_random)
> + pr_cont(", %s", trusted_key_sources[i].name);
> + pr_cont(", default\n");
> + return -EINVAL;
> + }
> + }
> +
> + if (!get_random)
> + get_random = kernel_get_random;
> +
> static_call_update(trusted_key_init,
> trusted_key_sources[i].ops->init);
> static_call_update(trusted_key_seal,
> @@ -329,7 +362,7 @@ static int __init init_trusted(void)
> static_call_update(trusted_key_unseal,
> trusted_key_sources[i].ops->unseal);
> static_call_update(trusted_key_get_random,
> - trusted_key_sources[i].ops->get_random);
> + get_random);
> static_call_update(trusted_key_exit,
> trusted_key_sources[i].ops->exit);
> migratable = trusted_key_sources[i].ops->migratable;
> --
> 2.30.2
>
Reviewed-by: Jarkko Sakkinen <jarkko@kernel.org>
BR, Jarkko
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH v5 3/5] KEYS: trusted: allow trust sources to use kernel RNG for key material
2022-02-22 19:58 [PATCH v5 0/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
2022-02-22 19:58 ` [PATCH v5 1/5] KEYS: trusted: allow use of TEE as backend without TCG_TPM support Ahmad Fatoum
2022-02-22 19:58 ` [PATCH v5 2/5] KEYS: trusted: allow users to use kernel RNG for key material Ahmad Fatoum
@ 2022-02-22 19:58 ` Ahmad Fatoum
2022-02-23 16:23 ` Ahmad Fatoum
2022-02-22 19:58 ` [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator Ahmad Fatoum
2022-02-22 19:58 ` [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
4 siblings, 1 reply; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-22 19:58 UTC (permalink / raw)
To: James Bottomley, Jarkko Sakkinen, Mimi Zohar, David Howells
Cc: kernel, Sumit Garg, David Gstir, Tim Harvey, Ahmad Fatoum,
James Morris, Serge E. Hallyn, Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, Eric Biggers,
Jan Luebbe, Richard Weinberger, Franck LENORMAND,
Matthias Schiffer, Pankaj Gupta, keyrings, linux-crypto,
linux-integrity, linux-kernel, linux-security-module
The two existing trusted key sources don't make use of the kernel RNG,
but instead let the hardware that does the sealing/unsealing also
generate the random key material. While a previous change offers users
the choice to use the kernel RNG instead for both, new trust sources
may want to unconditionally use the kernel RNG for generating key
material, like it's done elsewhere in the kernel.
This is especially prudent for hardware that has proven-in-production
HWRNG drivers implemented, as otherwise code would have to be duplicated
only to arrive at a possibly worse result.
Make this possible by turning struct trusted_key_ops::get_random
into an optional member. If a driver leaves it NULL, kernel RNG
will be used instead.
Acked-by: Sumit Garg <sumit.garg@linaro.org>
Reviewed-by: David Gstir <david@sigma-star.at>
Tested-By: Tim Harvey <tharvey@gateworks.com>
Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
To: James Bottomley <jejb@linux.ibm.com>
To: Jarkko Sakkinen <jarkko@kernel.org>
To: Mimi Zohar <zohar@linux.ibm.com>
To: David Howells <dhowells@redhat.com>
Cc: James Morris <jmorris@namei.org>
Cc: "Serge E. Hallyn" <serge@hallyn.com>
Cc: "Horia Geantă" <horia.geanta@nxp.com>
Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: Jan Luebbe <j.luebbe@pengutronix.de>
Cc: David Gstir <david@sigma-star.at>
Cc: Richard Weinberger <richard@nod.at>
Cc: Franck LENORMAND <franck.lenormand@nxp.com>
Cc: Sumit Garg <sumit.garg@linaro.org>
Cc: Tim Harvey <tharvey@gateworks.com>
Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
Cc: keyrings@vger.kernel.org
Cc: linux-crypto@vger.kernel.org
Cc: linux-integrity@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-security-module@vger.kernel.org
---
include/keys/trusted-type.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h
index d89fa2579ac0..4eb64548a74f 100644
--- a/include/keys/trusted-type.h
+++ b/include/keys/trusted-type.h
@@ -64,7 +64,7 @@ struct trusted_key_ops {
/* Unseal a key. */
int (*unseal)(struct trusted_key_payload *p, char *datablob);
- /* Get a randomized key. */
+ /* Optional: Get a randomized key. */
int (*get_random)(unsigned char *key, size_t key_len);
/* Exit key interface. */
--
2.30.2
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 3/5] KEYS: trusted: allow trust sources to use kernel RNG for key material
2022-02-22 19:58 ` [PATCH v5 3/5] KEYS: trusted: allow trust sources " Ahmad Fatoum
@ 2022-02-23 16:23 ` Ahmad Fatoum
2022-02-25 11:57 ` [EXT] " Pankaj Gupta
2022-03-02 4:43 ` Pankaj Gupta
0 siblings, 2 replies; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-23 16:23 UTC (permalink / raw)
To: James Bottomley, Jarkko Sakkinen, Mimi Zohar, David Howells
Cc: kernel, Sumit Garg, David Gstir, Tim Harvey, James Morris,
Serge E. Hallyn, Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, Eric Biggers,
Jan Luebbe, Richard Weinberger, Franck LENORMAND,
Matthias Schiffer, Pankaj Gupta, keyrings, linux-crypto,
linux-integrity, linux-kernel, linux-security-module
On 22.02.22 20:58, Ahmad Fatoum wrote:
> The two existing trusted key sources don't make use of the kernel RNG,
> but instead let the hardware that does the sealing/unsealing also
> generate the random key material. While a previous change offers users
> the choice to use the kernel RNG instead for both, new trust sources
> may want to unconditionally use the kernel RNG for generating key
> material, like it's done elsewhere in the kernel.
>
> This is especially prudent for hardware that has proven-in-production
> HWRNG drivers implemented, as otherwise code would have to be duplicated
> only to arrive at a possibly worse result.
>
> Make this possible by turning struct trusted_key_ops::get_random
> into an optional member. If a driver leaves it NULL, kernel RNG
> will be used instead.
The rebase on the change in scope of the previous commit made this
one here quite small. I would squash it into the previous commit
for v6, unless there are objections.
>
> Acked-by: Sumit Garg <sumit.garg@linaro.org>
> Reviewed-by: David Gstir <david@sigma-star.at>
> Tested-By: Tim Harvey <tharvey@gateworks.com>
> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> ---
> To: James Bottomley <jejb@linux.ibm.com>
> To: Jarkko Sakkinen <jarkko@kernel.org>
> To: Mimi Zohar <zohar@linux.ibm.com>
> To: David Howells <dhowells@redhat.com>
> Cc: James Morris <jmorris@namei.org>
> Cc: "Serge E. Hallyn" <serge@hallyn.com>
> Cc: "Horia Geantă" <horia.geanta@nxp.com>
> Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> Cc: Herbert Xu <herbert@gondor.apana.org.au>
> Cc: "David S. Miller" <davem@davemloft.net>
> Cc: Eric Biggers <ebiggers@kernel.org>
> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> Cc: David Gstir <david@sigma-star.at>
> Cc: Richard Weinberger <richard@nod.at>
> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> Cc: Sumit Garg <sumit.garg@linaro.org>
> Cc: Tim Harvey <tharvey@gateworks.com>
> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> Cc: keyrings@vger.kernel.org
> Cc: linux-crypto@vger.kernel.org
> Cc: linux-integrity@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> Cc: linux-security-module@vger.kernel.org
> ---
> include/keys/trusted-type.h | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h
> index d89fa2579ac0..4eb64548a74f 100644
> --- a/include/keys/trusted-type.h
> +++ b/include/keys/trusted-type.h
> @@ -64,7 +64,7 @@ struct trusted_key_ops {
> /* Unseal a key. */
> int (*unseal)(struct trusted_key_payload *p, char *datablob);
>
> - /* Get a randomized key. */
> + /* Optional: Get a randomized key. */
> int (*get_random)(unsigned char *key, size_t key_len);
>
> /* Exit key interface. */
--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread* RE: [EXT] Re: [PATCH v5 3/5] KEYS: trusted: allow trust sources to use kernel RNG for key material
2022-02-23 16:23 ` Ahmad Fatoum
@ 2022-02-25 11:57 ` Pankaj Gupta
2022-03-02 4:43 ` Pankaj Gupta
1 sibling, 0 replies; 19+ messages in thread
From: Pankaj Gupta @ 2022-02-25 11:57 UTC (permalink / raw)
To: Ahmad Fatoum, James Bottomley, Jarkko Sakkinen, Mimi Zohar,
David Howells
Cc: kernel, Sumit Garg, David Gstir, tharvey, James Morris,
Serge E. Hallyn, Horia Geanta, Aymen Sghaier, Herbert Xu,
David S. Miller, Eric Biggers, Jan Luebbe, Richard Weinberger,
Franck Lenormand, Matthias Schiffer, keyrings, linux-crypto,
linux-integrity, linux-kernel, linux-security-module
Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> -----Original Message-----
> From: Ahmad Fatoum <a.fatoum@pengutronix.de>
> Sent: Wednesday, February 23, 2022 9:53 PM
> To: James Bottomley <jejb@linux.ibm.com>; Jarkko Sakkinen
> <jarkko@kernel.org>; Mimi Zohar <zohar@linux.ibm.com>; David Howells
> <dhowells@redhat.com>
> Cc: kernel@pengutronix.de; Sumit Garg <sumit.garg@linaro.org>; David Gstir
> <david@sigma-star.at>; tharvey@gateworks.com; James Morris
> <jmorris@namei.org>; Serge E. Hallyn <serge@hallyn.com>; Horia Geanta
> <horia.geanta@nxp.com>; Aymen Sghaier <aymen.sghaier@nxp.com>; Herbert
> Xu <herbert@gondor.apana.org.au>; David S. Miller <davem@davemloft.net>;
> Eric Biggers <ebiggers@kernel.org>; Jan Luebbe <j.luebbe@pengutronix.de>;
> Richard Weinberger <richard@nod.at>; Franck Lenormand
> <franck.lenormand@nxp.com>; Matthias Schiffer <matthias.schiffer@ew.tq-
> group.com>; Pankaj Gupta <pankaj.gupta@nxp.com>; keyrings@vger.kernel.org;
> linux-crypto@vger.kernel.org; linux-integrity@vger.kernel.org; linux-
> kernel@vger.kernel.org; linux-security-module@vger.kernel.org
> Subject: [EXT] Re: [PATCH v5 3/5] KEYS: trusted: allow trust sources to use
> kernel RNG for key material
>
> Caution: EXT Email
>
> On 22.02.22 20:58, Ahmad Fatoum wrote:
> > The two existing trusted key sources don't make use of the kernel RNG,
> > but instead let the hardware that does the sealing/unsealing also
> > generate the random key material. While a previous change offers users
> > the choice to use the kernel RNG instead for both, new trust sources
> > may want to unconditionally use the kernel RNG for generating key
> > material, like it's done elsewhere in the kernel.
> >
> > This is especially prudent for hardware that has proven-in-production
> > HWRNG drivers implemented, as otherwise code would have to be
> > duplicated only to arrive at a possibly worse result.
> >
> > Make this possible by turning struct trusted_key_ops::get_random into
> > an optional member. If a driver leaves it NULL, kernel RNG will be
> > used instead.
>
> The rebase on the change in scope of the previous commit made this one here
> quite small. I would squash it into the previous commit for v6, unless there are
> objections.
>
>
> >
> > Acked-by: Sumit Garg <sumit.garg@linaro.org>
> > Reviewed-by: David Gstir <david@sigma-star.at>
> > Tested-By: Tim Harvey <tharvey@gateworks.com>
> > Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> > ---
> > To: James Bottomley <jejb@linux.ibm.com>
> > To: Jarkko Sakkinen <jarkko@kernel.org>
> > To: Mimi Zohar <zohar@linux.ibm.com>
> > To: David Howells <dhowells@redhat.com>
> > Cc: James Morris <jmorris@namei.org>
> > Cc: "Serge E. Hallyn" <serge@hallyn.com>
> > Cc: "Horia Geantă" <horia.geanta@nxp.com>
> > Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> > Cc: Herbert Xu <herbert@gondor.apana.org.au>
> > Cc: "David S. Miller" <davem@davemloft.net>
> > Cc: Eric Biggers <ebiggers@kernel.org>
> > Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> > Cc: David Gstir <david@sigma-star.at>
> > Cc: Richard Weinberger <richard@nod.at>
> > Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> > Cc: Sumit Garg <sumit.garg@linaro.org>
> > Cc: Tim Harvey <tharvey@gateworks.com>
> > Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> > Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> > Cc: keyrings@vger.kernel.org
> > Cc: linux-crypto@vger.kernel.org
> > Cc: linux-integrity@vger.kernel.org
> > Cc: linux-kernel@vger.kernel.org
> > Cc: linux-security-module@vger.kernel.org
> > ---
> > include/keys/trusted-type.h | 2 +-
> > 1 file changed, 1 insertion(+), 1 deletion(-)
> >
> > diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h
> > index d89fa2579ac0..4eb64548a74f 100644
> > --- a/include/keys/trusted-type.h
> > +++ b/include/keys/trusted-type.h
> > @@ -64,7 +64,7 @@ struct trusted_key_ops {
> > /* Unseal a key. */
> > int (*unseal)(struct trusted_key_payload *p, char *datablob);
> >
> > - /* Get a randomized key. */
> > + /* Optional: Get a randomized key. */
> > int (*get_random)(unsigned char *key, size_t key_len);
> >
> > /* Exit key interface. */
>
>
> --
> Pengutronix e.K. | |
> Steuerwalder Str. 21 |
> https://eur01.safelinks.protection.outlook.com/?url=http%3A%2F%2Fwww.pen
> gutronix.de%2F&data=04%7C01%7Cpankaj.gupta%40nxp.com%7Cd6143a
> 1791a8494849f208d9f6e8cef8%7C686ea1d3bc2b4c6fa92cd99c5c301635%7C0
> %7C0%7C637812302026139014%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4
> wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000&am
> p;sdata=2QRFygy%2BVafXrLIkF1BOHtDiwP%2Fz9kwU9ovtG1WJBTY%3D&r
> eserved=0 |
> 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread* RE: [EXT] Re: [PATCH v5 3/5] KEYS: trusted: allow trust sources to use kernel RNG for key material
2022-02-23 16:23 ` Ahmad Fatoum
2022-02-25 11:57 ` [EXT] " Pankaj Gupta
@ 2022-03-02 4:43 ` Pankaj Gupta
1 sibling, 0 replies; 19+ messages in thread
From: Pankaj Gupta @ 2022-03-02 4:43 UTC (permalink / raw)
To: Ahmad Fatoum, James Bottomley, Jarkko Sakkinen, Mimi Zohar,
David Howells
Cc: kernel, Sumit Garg, David Gstir, tharvey, James Morris,
Serge E. Hallyn, Horia Geanta, Aymen Sghaier, Herbert Xu,
David S. Miller, Eric Biggers, Jan Luebbe, Richard Weinberger,
Franck Lenormand, Matthias Schiffer, keyrings, linux-crypto,
linux-integrity, linux-kernel, linux-security-module
Acked-by: Pankaj Gupta <pankaj.gupta@nxp.com>
Regards
Pankaj
> -----Original Message-----
> From: Ahmad Fatoum <a.fatoum@pengutronix.de>
> Sent: Wednesday, February 23, 2022 9:53 PM
> To: James Bottomley <jejb@linux.ibm.com>; Jarkko Sakkinen
> <jarkko@kernel.org>; Mimi Zohar <zohar@linux.ibm.com>; David Howells
> <dhowells@redhat.com>
> Cc: kernel@pengutronix.de; Sumit Garg <sumit.garg@linaro.org>; David Gstir
> <david@sigma-star.at>; tharvey@gateworks.com; James Morris
> <jmorris@namei.org>; Serge E. Hallyn <serge@hallyn.com>; Horia Geanta
> <horia.geanta@nxp.com>; Aymen Sghaier <aymen.sghaier@nxp.com>;
> Herbert Xu <herbert@gondor.apana.org.au>; David S. Miller
> <davem@davemloft.net>; Eric Biggers <ebiggers@kernel.org>; Jan Luebbe
> <j.luebbe@pengutronix.de>; Richard Weinberger <richard@nod.at>; Franck
> Lenormand <franck.lenormand@nxp.com>; Matthias Schiffer
> <matthias.schiffer@ew.tq-group.com>; Pankaj Gupta
> <pankaj.gupta@nxp.com>; keyrings@vger.kernel.org; linux-
> crypto@vger.kernel.org; linux-integrity@vger.kernel.org; linux-
> kernel@vger.kernel.org; linux-security-module@vger.kernel.org
> Subject: [EXT] Re: [PATCH v5 3/5] KEYS: trusted: allow trust sources to use
> kernel RNG for key material
>
> Caution: EXT Email
>
> On 22.02.22 20:58, Ahmad Fatoum wrote:
> > The two existing trusted key sources don't make use of the kernel RNG,
> > but instead let the hardware that does the sealing/unsealing also
> > generate the random key material. While a previous change offers users
> > the choice to use the kernel RNG instead for both, new trust sources
> > may want to unconditionally use the kernel RNG for generating key
> > material, like it's done elsewhere in the kernel.
> >
> > This is especially prudent for hardware that has proven-in-production
> > HWRNG drivers implemented, as otherwise code would have to be
> > duplicated only to arrive at a possibly worse result.
> >
> > Make this possible by turning struct trusted_key_ops::get_random into
> > an optional member. If a driver leaves it NULL, kernel RNG will be
> > used instead.
>
> The rebase on the change in scope of the previous commit made this one
> here quite small. I would squash it into the previous commit for v6, unless
> there are objections.
>
>
> >
> > Acked-by: Sumit Garg <sumit.garg@linaro.org>
> > Reviewed-by: David Gstir <david@sigma-star.at>
> > Tested-By: Tim Harvey <tharvey@gateworks.com>
> > Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> > ---
> > To: James Bottomley <jejb@linux.ibm.com>
> > To: Jarkko Sakkinen <jarkko@kernel.org>
> > To: Mimi Zohar <zohar@linux.ibm.com>
> > To: David Howells <dhowells@redhat.com>
> > Cc: James Morris <jmorris@namei.org>
> > Cc: "Serge E. Hallyn" <serge@hallyn.com>
> > Cc: "Horia Geantă" <horia.geanta@nxp.com>
> > Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> > Cc: Herbert Xu <herbert@gondor.apana.org.au>
> > Cc: "David S. Miller" <davem@davemloft.net>
> > Cc: Eric Biggers <ebiggers@kernel.org>
> > Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> > Cc: David Gstir <david@sigma-star.at>
> > Cc: Richard Weinberger <richard@nod.at>
> > Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> > Cc: Sumit Garg <sumit.garg@linaro.org>
> > Cc: Tim Harvey <tharvey@gateworks.com>
> > Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> > Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> > Cc: keyrings@vger.kernel.org
> > Cc: linux-crypto@vger.kernel.org
> > Cc: linux-integrity@vger.kernel.org
> > Cc: linux-kernel@vger.kernel.org
> > Cc: linux-security-module@vger.kernel.org
> > ---
> > include/keys/trusted-type.h | 2 +-
> > 1 file changed, 1 insertion(+), 1 deletion(-)
> >
> > diff --git a/include/keys/trusted-type.h b/include/keys/trusted-type.h
> > index d89fa2579ac0..4eb64548a74f 100644
> > --- a/include/keys/trusted-type.h
> > +++ b/include/keys/trusted-type.h
> > @@ -64,7 +64,7 @@ struct trusted_key_ops {
> > /* Unseal a key. */
> > int (*unseal)(struct trusted_key_payload *p, char *datablob);
> >
> > - /* Get a randomized key. */
> > + /* Optional: Get a randomized key. */
> > int (*get_random)(unsigned char *key, size_t key_len);
> >
> > /* Exit key interface. */
>
>
> --
> Pengutronix e.K. | |
> Steuerwalder Str. 21 |
> https://eur01.safelinks.protection.outlook.com/?url=http%3A%2F%2Fwww.
> pengutronix.de%2F&data=04%7C01%7Cpankaj.gupta%40nxp.com%7Cd
> 6143a1791a8494849f208d9f6e8cef8%7C686ea1d3bc2b4c6fa92cd99c5c301635
> %7C0%7C0%7C637812302026139014%7CUnknown%7CTWFpbGZsb3d8eyJWIj
> oiMC4wLjAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3
> 000&sdata=2QRFygy%2BVafXrLIkF1BOHtDiwP%2Fz9kwU9ovtG1WJBTY
> %3D&reserved=0 |
> 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-22 19:58 [PATCH v5 0/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
` (2 preceding siblings ...)
2022-02-22 19:58 ` [PATCH v5 3/5] KEYS: trusted: allow trust sources " Ahmad Fatoum
@ 2022-02-22 19:58 ` Ahmad Fatoum
2022-02-23 15:41 ` Jarkko Sakkinen
2022-02-22 19:58 ` [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
4 siblings, 1 reply; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-22 19:58 UTC (permalink / raw)
To: Horia Geantă, Aymen Sghaier, Herbert Xu, David S. Miller
Cc: kernel, David Gstir, Pankaj Gupta, Tim Harvey, Matthias Schiffer,
Ahmad Fatoum, James Bottomley, Jarkko Sakkinen, Mimi Zohar,
David Howells, James Morris, Eric Biggers, Serge E. Hallyn,
Jan Luebbe, Richard Weinberger, Franck LENORMAND, Sumit Garg,
linux-integrity, keyrings, linux-crypto, linux-kernel,
linux-security-module
The NXP Cryptographic Acceleration and Assurance Module (CAAM)
can be used to protect user-defined data across system reboot:
- When the system is fused and boots into secure state, the master
key is a unique never-disclosed device-specific key
- random key is encrypted by key derived from master key
- data is encrypted using the random key
- encrypted data and its encrypted random key are stored alongside
- This blob can now be safely stored in non-volatile memory
On next power-on:
- blob is loaded into CAAM
- CAAM writes decrypted data either into memory or key register
Add functions to realize encrypting and decrypting into memory alongside
the CAAM driver.
They will be used in a later commit as a source for the trusted key
seal/unseal mechanism.
Reviewed-by: David Gstir <david@sigma-star.at>
Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
Tested-By: Tim Harvey <tharvey@gateworks.com>
Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
To: "Horia Geantă" <horia.geanta@nxp.com>
To: Aymen Sghaier <aymen.sghaier@nxp.com>
To: Herbert Xu <herbert@gondor.apana.org.au>
To: "David S. Miller" <davem@davemloft.net>
Cc: James Bottomley <jejb@linux.ibm.com>
Cc: Jarkko Sakkinen <jarkko@kernel.org>
Cc: Mimi Zohar <zohar@linux.ibm.com>
Cc: David Howells <dhowells@redhat.com>
Cc: James Morris <jmorris@namei.org>
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: "Serge E. Hallyn" <serge@hallyn.com>
Cc: Jan Luebbe <j.luebbe@pengutronix.de>
Cc: David Gstir <david@sigma-star.at>
Cc: Richard Weinberger <richard@nod.at>
Cc: Franck LENORMAND <franck.lenormand@nxp.com>
Cc: Sumit Garg <sumit.garg@linaro.org>
Cc: Tim Harvey <tharvey@gateworks.com>
Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
Cc: linux-integrity@vger.kernel.org
Cc: keyrings@vger.kernel.org
Cc: linux-crypto@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-security-module@vger.kernel.org
---
drivers/crypto/caam/Kconfig | 3 +
drivers/crypto/caam/Makefile | 1 +
drivers/crypto/caam/blob_gen.c | 230 +++++++++++++++++++++++++++++++++
include/soc/fsl/caam-blob.h | 56 ++++++++
4 files changed, 290 insertions(+)
create mode 100644 drivers/crypto/caam/blob_gen.c
create mode 100644 include/soc/fsl/caam-blob.h
diff --git a/drivers/crypto/caam/Kconfig b/drivers/crypto/caam/Kconfig
index 84ea7cba5ee5..ea9f8b1ae981 100644
--- a/drivers/crypto/caam/Kconfig
+++ b/drivers/crypto/caam/Kconfig
@@ -151,6 +151,9 @@ config CRYPTO_DEV_FSL_CAAM_RNG_API
Selecting this will register the SEC4 hardware rng to
the hw_random API for supplying the kernel entropy pool.
+config CRYPTO_DEV_FSL_CAAM_BLOB_GEN
+ bool
+
endif # CRYPTO_DEV_FSL_CAAM_JR
endif # CRYPTO_DEV_FSL_CAAM
diff --git a/drivers/crypto/caam/Makefile b/drivers/crypto/caam/Makefile
index 3570286eb9ce..25f7ae5a4642 100644
--- a/drivers/crypto/caam/Makefile
+++ b/drivers/crypto/caam/Makefile
@@ -21,6 +21,7 @@ caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += caamalg_qi.o
caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_AHASH_API) += caamhash.o
caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_RNG_API) += caamrng.o
caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_PKC_API) += caampkc.o pkc_desc.o
+caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_BLOB_GEN) += blob_gen.o
caam-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += qi.o
ifneq ($(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI),)
diff --git a/drivers/crypto/caam/blob_gen.c b/drivers/crypto/caam/blob_gen.c
new file mode 100644
index 000000000000..513d3f90e438
--- /dev/null
+++ b/drivers/crypto/caam/blob_gen.c
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2015 Pengutronix, Steffen Trumtrar <kernel@pengutronix.de>
+ * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
+ */
+
+#include <linux/device.h>
+#include <soc/fsl/caam-blob.h>
+
+#include "compat.h"
+#include "desc_constr.h"
+#include "desc.h"
+#include "error.h"
+#include "intern.h"
+#include "jr.h"
+#include "regs.h"
+
+struct caam_blob_priv {
+ struct device jrdev;
+};
+
+struct caam_blob_job_result {
+ int err;
+ struct completion completion;
+};
+
+static void caam_blob_job_done(struct device *dev, u32 *desc, u32 err, void *context)
+{
+ struct caam_blob_job_result *res = context;
+ int ecode = 0;
+
+ dev_dbg(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
+
+ if (err)
+ ecode = caam_jr_strstatus(dev, err);
+
+ res->err = ecode;
+
+ /*
+ * Upon completion, desc points to a buffer containing a CAAM job
+ * descriptor which encapsulates data into an externally-storable
+ * blob.
+ */
+ complete(&res->completion);
+}
+
+static u32 *caam_blob_alloc_desc(size_t keymod_len)
+{
+ size_t len;
+
+ /* header + (key mod immediate) + 2x pointers + op */
+ len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 + CAAM_PTR_SZ_MAX) + 4;
+
+ if (len > CAAM_DESC_BYTES_MAX)
+ return NULL;
+
+ return kzalloc(len, GFP_KERNEL | GFP_DMA);
+}
+
+int caam_encap_blob(struct caam_blob_priv *priv, const char *keymod,
+ void *input, void *output, size_t length)
+{
+ u32 *desc;
+ struct device *jrdev = &priv->jrdev;
+ dma_addr_t dma_in, dma_out;
+ struct caam_blob_job_result testres;
+ size_t keymod_len = strlen(keymod);
+ int ret;
+
+ if (length <= CAAM_BLOB_OVERHEAD || keymod_len > CAAM_BLOB_KEYMOD_LENGTH)
+ return -EINVAL;
+
+ desc = caam_blob_alloc_desc(keymod_len);
+ if (!desc) {
+ dev_err(jrdev, "unable to allocate desc\n");
+ return -ENOMEM;
+ }
+
+ dma_in = dma_map_single(jrdev, input, length - CAAM_BLOB_OVERHEAD, DMA_TO_DEVICE);
+ if (dma_mapping_error(jrdev, dma_in)) {
+ dev_err(jrdev, "unable to map input DMA buffer\n");
+ ret = -ENOMEM;
+ goto out_free;
+ }
+
+ dma_out = dma_map_single(jrdev, output, length, DMA_FROM_DEVICE);
+ if (dma_mapping_error(jrdev, dma_out)) {
+ dev_err(jrdev, "unable to map output DMA buffer\n");
+ ret = -ENOMEM;
+ goto out_unmap_in;
+ }
+
+ /*
+ * A data blob is encrypted using a blob key (BK); a random number.
+ * The BK is used as an AES-CCM key. The initial block (B0) and the
+ * initial counter (Ctr0) are generated automatically and stored in
+ * Class 1 Context DWords 0+1+2+3. The random BK is stored in the
+ * Class 1 Key Register. Operation Mode is set to AES-CCM.
+ */
+
+ init_job_desc(desc, 0);
+ append_key_as_imm(desc, keymod, keymod_len, keymod_len,
+ CLASS_2 | KEY_DEST_CLASS_REG);
+ append_seq_in_ptr_intlen(desc, dma_in, length - CAAM_BLOB_OVERHEAD, 0);
+ append_seq_out_ptr_intlen(desc, dma_out, length, 0);
+ append_operation(desc, OP_TYPE_ENCAP_PROTOCOL | OP_PCLID_BLOB);
+
+ print_hex_dump_debug("data@"__stringify(__LINE__)": ",
+ DUMP_PREFIX_ADDRESS, 16, 1, input,
+ length - CAAM_BLOB_OVERHEAD, false);
+ print_hex_dump_debug("jobdesc@"__stringify(__LINE__)": ",
+ DUMP_PREFIX_ADDRESS, 16, 1, desc,
+ desc_bytes(desc), false);
+
+ testres.err = 0;
+ init_completion(&testres.completion);
+
+ ret = caam_jr_enqueue(jrdev, desc, caam_blob_job_done, &testres);
+ if (ret == -EINPROGRESS) {
+ wait_for_completion(&testres.completion);
+ ret = testres.err;
+ print_hex_dump_debug("output@"__stringify(__LINE__)": ",
+ DUMP_PREFIX_ADDRESS, 16, 1, output,
+ length, false);
+ }
+
+ dma_unmap_single(jrdev, dma_out, length, DMA_FROM_DEVICE);
+out_unmap_in:
+ dma_unmap_single(jrdev, dma_in, length - CAAM_BLOB_OVERHEAD, DMA_TO_DEVICE);
+out_free:
+ kfree(desc);
+
+ return ret;
+}
+EXPORT_SYMBOL(caam_encap_blob);
+
+int caam_decap_blob(struct caam_blob_priv *priv, const char *keymod,
+ void *input, void *output, size_t length)
+{
+ u32 *desc;
+ struct device *jrdev = &priv->jrdev;
+ dma_addr_t dma_in, dma_out;
+ struct caam_blob_job_result testres;
+ size_t keymod_len = strlen(keymod);
+ int ret;
+
+ if (length <= CAAM_BLOB_OVERHEAD || keymod_len > CAAM_BLOB_KEYMOD_LENGTH)
+ return -EINVAL;
+
+ desc = caam_blob_alloc_desc(keymod_len);
+ if (!desc) {
+ dev_err(jrdev, "unable to allocate desc\n");
+ return -ENOMEM;
+ }
+
+ dma_in = dma_map_single(jrdev, input, length, DMA_TO_DEVICE);
+ if (dma_mapping_error(jrdev, dma_in)) {
+ dev_err(jrdev, "unable to map input DMA buffer\n");
+ ret = -ENOMEM;
+ goto out_free;
+ }
+
+ dma_out = dma_map_single(jrdev, output, length - CAAM_BLOB_OVERHEAD, DMA_FROM_DEVICE);
+ if (dma_mapping_error(jrdev, dma_out)) {
+ dev_err(jrdev, "unable to map output DMA buffer\n");
+ ret = -ENOMEM;
+ goto out_unmap_in;
+ }
+
+ /*
+ * A data blob is encrypted using a blob key (BK); a random number.
+ * The BK is used as an AES-CCM key. The initial block (B0) and the
+ * initial counter (Ctr0) are generated automatically and stored in
+ * Class 1 Context DWords 0+1+2+3. The random BK is stored in the
+ * Class 1 Key Register. Operation Mode is set to AES-CCM.
+ */
+
+ init_job_desc(desc, 0);
+ append_key_as_imm(desc, keymod, keymod_len, keymod_len,
+ CLASS_2 | KEY_DEST_CLASS_REG);
+ append_seq_in_ptr(desc, dma_in, length, 0);
+ append_seq_out_ptr(desc, dma_out, length - CAAM_BLOB_OVERHEAD, 0);
+ append_operation(desc, OP_TYPE_DECAP_PROTOCOL | OP_PCLID_BLOB);
+
+ print_hex_dump_debug("data@"__stringify(__LINE__)": ",
+ DUMP_PREFIX_ADDRESS, 16, 1, input,
+ length, false);
+ print_hex_dump_debug("jobdesc@"__stringify(__LINE__)": ",
+ DUMP_PREFIX_ADDRESS, 16, 1, desc,
+ desc_bytes(desc), false);
+
+ testres.err = 0;
+ init_completion(&testres.completion);
+
+ ret = caam_jr_enqueue(jrdev, desc, caam_blob_job_done, &testres);
+ if (ret == -EINPROGRESS) {
+ wait_for_completion(&testres.completion);
+ ret = testres.err;
+ print_hex_dump_debug("output@"__stringify(__LINE__)": ",
+ DUMP_PREFIX_ADDRESS, 16, 1, output,
+ length - CAAM_BLOB_OVERHEAD, false);
+ }
+
+ dma_unmap_single(jrdev, dma_out, length - CAAM_BLOB_OVERHEAD, DMA_FROM_DEVICE);
+out_unmap_in:
+ dma_unmap_single(jrdev, dma_in, length, DMA_TO_DEVICE);
+out_free:
+ kfree(desc);
+
+ return ret;
+}
+EXPORT_SYMBOL(caam_decap_blob);
+
+struct caam_blob_priv *caam_blob_gen_init(void)
+{
+ struct device *jrdev;
+
+ jrdev = caam_jr_alloc();
+ if (IS_ERR(jrdev))
+ return ERR_CAST(jrdev);
+
+ return container_of(jrdev, struct caam_blob_priv, jrdev);
+}
+EXPORT_SYMBOL(caam_blob_gen_init);
+
+void caam_blob_gen_exit(struct caam_blob_priv *priv)
+{
+ caam_jr_free(&priv->jrdev);
+}
+EXPORT_SYMBOL(caam_blob_gen_exit);
diff --git a/include/soc/fsl/caam-blob.h b/include/soc/fsl/caam-blob.h
new file mode 100644
index 000000000000..83fd990ebdce
--- /dev/null
+++ b/include/soc/fsl/caam-blob.h
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2020 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
+ */
+
+#ifndef __CAAM_BLOB_GEN
+#define __CAAM_BLOB_GEN
+
+#include <linux/types.h>
+
+#define CAAM_BLOB_KEYMOD_LENGTH 16
+#define CAAM_BLOB_OVERHEAD (32 + 16)
+#define CAAM_BLOB_MAX_LEN 4096
+
+struct caam_blob_priv;
+
+/** caam_blob_gen_init - initialize blob generation
+ *
+ * returns either pointer to new caam_blob_priv instance
+ * or error pointer
+ */
+struct caam_blob_priv *caam_blob_gen_init(void);
+
+/** caam_blob_gen_exit - free blob generation resources
+ *
+ * @priv: instance returned by caam_blob_gen_init
+ */
+void caam_blob_gen_exit(struct caam_blob_priv *priv);
+
+/** caam_encap_blob - encapsulate blob
+ *
+ * @priv: instance returned by caam_blob_gen_init
+ * @keymod: string to use as key modifier for blob encapsulation
+ * can't be longer than CAAM_BLOB_KEYMOD_LENGTH
+ * @input: buffer which CAAM will DMA from
+ * @output: buffer which CAAM will DMA to
+ * @length: buffer length including blob overhead
+ * CAAM_BLOB_OVERHEAD < length <= CAAM_BLOB_MAX_LEN
+ */
+int caam_encap_blob(struct caam_blob_priv *priv, const char *keymod,
+ void *input, void *output, size_t length);
+
+/** caam_decap_blob - decapsulate blob
+ *
+ * @priv: instance returned by caam_blob_gen_init
+ * @keymod: string to use as key modifier for blob decapsulation
+ * can't be longer than CAAM_BLOB_KEYMOD_LENGTH
+ * @input: buffer which CAAM will DMA from
+ * @output: buffer which CAAM will DMA to
+ * @length: buffer length including blob overhead
+ * CAAM_BLOB_OVERHEAD < length <= CAAM_BLOB_MAX_LEN
+ */
+int caam_decap_blob(struct caam_blob_priv *priv, const char *keymod,
+ void *input, void *output, size_t length);
+
+#endif
--
2.30.2
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-22 19:58 ` [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator Ahmad Fatoum
@ 2022-02-23 15:41 ` Jarkko Sakkinen
2022-02-23 16:20 ` Ahmad Fatoum
0 siblings, 1 reply; 19+ messages in thread
From: Jarkko Sakkinen @ 2022-02-23 15:41 UTC (permalink / raw)
To: Ahmad Fatoum
Cc: Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, kernel, David Gstir,
Pankaj Gupta, Tim Harvey, Matthias Schiffer, James Bottomley,
Mimi Zohar, David Howells, James Morris, Eric Biggers,
Serge E. Hallyn, Jan Luebbe, Richard Weinberger,
Franck LENORMAND, Sumit Garg, linux-integrity, keyrings,
linux-crypto, linux-kernel, linux-security-module
On Tue, Feb 22, 2022 at 08:58:18PM +0100, Ahmad Fatoum wrote:
> The NXP Cryptographic Acceleration and Assurance Module (CAAM)
> can be used to protect user-defined data across system reboot:
>
> - When the system is fused and boots into secure state, the master
> key is a unique never-disclosed device-specific key
> - random key is encrypted by key derived from master key
> - data is encrypted using the random key
> - encrypted data and its encrypted random key are stored alongside
> - This blob can now be safely stored in non-volatile memory
>
> On next power-on:
> - blob is loaded into CAAM
> - CAAM writes decrypted data either into memory or key register
>
> Add functions to realize encrypting and decrypting into memory alongside
> the CAAM driver.
>
> They will be used in a later commit as a source for the trusted key
> seal/unseal mechanism.
>
> Reviewed-by: David Gstir <david@sigma-star.at>
> Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> Tested-By: Tim Harvey <tharvey@gateworks.com>
> Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> ---
> To: "Horia Geantă" <horia.geanta@nxp.com>
> To: Aymen Sghaier <aymen.sghaier@nxp.com>
> To: Herbert Xu <herbert@gondor.apana.org.au>
> To: "David S. Miller" <davem@davemloft.net>
> Cc: James Bottomley <jejb@linux.ibm.com>
> Cc: Jarkko Sakkinen <jarkko@kernel.org>
> Cc: Mimi Zohar <zohar@linux.ibm.com>
> Cc: David Howells <dhowells@redhat.com>
> Cc: James Morris <jmorris@namei.org>
> Cc: Eric Biggers <ebiggers@kernel.org>
> Cc: "Serge E. Hallyn" <serge@hallyn.com>
> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> Cc: David Gstir <david@sigma-star.at>
> Cc: Richard Weinberger <richard@nod.at>
> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> Cc: Sumit Garg <sumit.garg@linaro.org>
> Cc: Tim Harvey <tharvey@gateworks.com>
> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> Cc: linux-integrity@vger.kernel.org
> Cc: keyrings@vger.kernel.org
> Cc: linux-crypto@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> Cc: linux-security-module@vger.kernel.org
> ---
> drivers/crypto/caam/Kconfig | 3 +
> drivers/crypto/caam/Makefile | 1 +
> drivers/crypto/caam/blob_gen.c | 230 +++++++++++++++++++++++++++++++++
> include/soc/fsl/caam-blob.h | 56 ++++++++
> 4 files changed, 290 insertions(+)
> create mode 100644 drivers/crypto/caam/blob_gen.c
> create mode 100644 include/soc/fsl/caam-blob.h
>
> diff --git a/drivers/crypto/caam/Kconfig b/drivers/crypto/caam/Kconfig
> index 84ea7cba5ee5..ea9f8b1ae981 100644
> --- a/drivers/crypto/caam/Kconfig
> +++ b/drivers/crypto/caam/Kconfig
> @@ -151,6 +151,9 @@ config CRYPTO_DEV_FSL_CAAM_RNG_API
> Selecting this will register the SEC4 hardware rng to
> the hw_random API for supplying the kernel entropy pool.
>
> +config CRYPTO_DEV_FSL_CAAM_BLOB_GEN
> + bool
> +
> endif # CRYPTO_DEV_FSL_CAAM_JR
>
> endif # CRYPTO_DEV_FSL_CAAM
> diff --git a/drivers/crypto/caam/Makefile b/drivers/crypto/caam/Makefile
> index 3570286eb9ce..25f7ae5a4642 100644
> --- a/drivers/crypto/caam/Makefile
> +++ b/drivers/crypto/caam/Makefile
> @@ -21,6 +21,7 @@ caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += caamalg_qi.o
> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_AHASH_API) += caamhash.o
> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_RNG_API) += caamrng.o
> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_PKC_API) += caampkc.o pkc_desc.o
> +caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_BLOB_GEN) += blob_gen.o
>
> caam-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += qi.o
> ifneq ($(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI),)
> diff --git a/drivers/crypto/caam/blob_gen.c b/drivers/crypto/caam/blob_gen.c
> new file mode 100644
> index 000000000000..513d3f90e438
> --- /dev/null
> +++ b/drivers/crypto/caam/blob_gen.c
> @@ -0,0 +1,230 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2015 Pengutronix, Steffen Trumtrar <kernel@pengutronix.de>
> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
> + */
> +
> +#include <linux/device.h>
> +#include <soc/fsl/caam-blob.h>
> +
> +#include "compat.h"
> +#include "desc_constr.h"
> +#include "desc.h"
> +#include "error.h"
> +#include "intern.h"
> +#include "jr.h"
> +#include "regs.h"
> +
> +struct caam_blob_priv {
> + struct device jrdev;
> +};
> +
> +struct caam_blob_job_result {
> + int err;
> + struct completion completion;
> +};
> +
> +static void caam_blob_job_done(struct device *dev, u32 *desc, u32 err, void *context)
> +{
> + struct caam_blob_job_result *res = context;
> + int ecode = 0;
> +
> + dev_dbg(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
> +
> + if (err)
> + ecode = caam_jr_strstatus(dev, err);
> +
> + res->err = ecode;
> +
> + /*
> + * Upon completion, desc points to a buffer containing a CAAM job
> + * descriptor which encapsulates data into an externally-storable
> + * blob.
> + */
> + complete(&res->completion);
> +}
> +
> +static u32 *caam_blob_alloc_desc(size_t keymod_len)
> +{
> + size_t len;
> +
> + /* header + (key mod immediate) + 2x pointers + op */
> + len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 + CAAM_PTR_SZ_MAX) + 4;
Nit: the amount of magic numbers is overwhelming here. I neither understand
the statement nor how that comment should help me to understand it.
BR, Jarkko
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-23 15:41 ` Jarkko Sakkinen
@ 2022-02-23 16:20 ` Ahmad Fatoum
2022-02-25 12:20 ` [EXT] " Pankaj Gupta
2022-02-28 12:14 ` Jarkko Sakkinen
0 siblings, 2 replies; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-23 16:20 UTC (permalink / raw)
To: Jarkko Sakkinen
Cc: Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, kernel, David Gstir,
Pankaj Gupta, Tim Harvey, Matthias Schiffer, James Bottomley,
Mimi Zohar, David Howells, James Morris, Eric Biggers,
Serge E. Hallyn, Jan Luebbe, Richard Weinberger,
Franck LENORMAND, Sumit Garg, linux-integrity, keyrings,
linux-crypto, linux-kernel, linux-security-module
On 23.02.22 16:41, Jarkko Sakkinen wrote:
> On Tue, Feb 22, 2022 at 08:58:18PM +0100, Ahmad Fatoum wrote:
>> The NXP Cryptographic Acceleration and Assurance Module (CAAM)
>> can be used to protect user-defined data across system reboot:
>>
>> - When the system is fused and boots into secure state, the master
>> key is a unique never-disclosed device-specific key
>> - random key is encrypted by key derived from master key
>> - data is encrypted using the random key
>> - encrypted data and its encrypted random key are stored alongside
>> - This blob can now be safely stored in non-volatile memory
>>
>> On next power-on:
>> - blob is loaded into CAAM
>> - CAAM writes decrypted data either into memory or key register
>>
>> Add functions to realize encrypting and decrypting into memory alongside
>> the CAAM driver.
>>
>> They will be used in a later commit as a source for the trusted key
>> seal/unseal mechanism.
>>
>> Reviewed-by: David Gstir <david@sigma-star.at>
>> Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
>> Tested-By: Tim Harvey <tharvey@gateworks.com>
>> Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
>> Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
>> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
>> ---
>> To: "Horia Geantă" <horia.geanta@nxp.com>
>> To: Aymen Sghaier <aymen.sghaier@nxp.com>
>> To: Herbert Xu <herbert@gondor.apana.org.au>
>> To: "David S. Miller" <davem@davemloft.net>
>> Cc: James Bottomley <jejb@linux.ibm.com>
>> Cc: Jarkko Sakkinen <jarkko@kernel.org>
>> Cc: Mimi Zohar <zohar@linux.ibm.com>
>> Cc: David Howells <dhowells@redhat.com>
>> Cc: James Morris <jmorris@namei.org>
>> Cc: Eric Biggers <ebiggers@kernel.org>
>> Cc: "Serge E. Hallyn" <serge@hallyn.com>
>> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
>> Cc: David Gstir <david@sigma-star.at>
>> Cc: Richard Weinberger <richard@nod.at>
>> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
>> Cc: Sumit Garg <sumit.garg@linaro.org>
>> Cc: Tim Harvey <tharvey@gateworks.com>
>> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
>> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
>> Cc: linux-integrity@vger.kernel.org
>> Cc: keyrings@vger.kernel.org
>> Cc: linux-crypto@vger.kernel.org
>> Cc: linux-kernel@vger.kernel.org
>> Cc: linux-security-module@vger.kernel.org
>> ---
>> drivers/crypto/caam/Kconfig | 3 +
>> drivers/crypto/caam/Makefile | 1 +
>> drivers/crypto/caam/blob_gen.c | 230 +++++++++++++++++++++++++++++++++
>> include/soc/fsl/caam-blob.h | 56 ++++++++
>> 4 files changed, 290 insertions(+)
>> create mode 100644 drivers/crypto/caam/blob_gen.c
>> create mode 100644 include/soc/fsl/caam-blob.h
>>
>> diff --git a/drivers/crypto/caam/Kconfig b/drivers/crypto/caam/Kconfig
>> index 84ea7cba5ee5..ea9f8b1ae981 100644
>> --- a/drivers/crypto/caam/Kconfig
>> +++ b/drivers/crypto/caam/Kconfig
>> @@ -151,6 +151,9 @@ config CRYPTO_DEV_FSL_CAAM_RNG_API
>> Selecting this will register the SEC4 hardware rng to
>> the hw_random API for supplying the kernel entropy pool.
>>
>> +config CRYPTO_DEV_FSL_CAAM_BLOB_GEN
>> + bool
>> +
>> endif # CRYPTO_DEV_FSL_CAAM_JR
>>
>> endif # CRYPTO_DEV_FSL_CAAM
>> diff --git a/drivers/crypto/caam/Makefile b/drivers/crypto/caam/Makefile
>> index 3570286eb9ce..25f7ae5a4642 100644
>> --- a/drivers/crypto/caam/Makefile
>> +++ b/drivers/crypto/caam/Makefile
>> @@ -21,6 +21,7 @@ caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += caamalg_qi.o
>> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_AHASH_API) += caamhash.o
>> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_RNG_API) += caamrng.o
>> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_PKC_API) += caampkc.o pkc_desc.o
>> +caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_BLOB_GEN) += blob_gen.o
>>
>> caam-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += qi.o
>> ifneq ($(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI),)
>> diff --git a/drivers/crypto/caam/blob_gen.c b/drivers/crypto/caam/blob_gen.c
>> new file mode 100644
>> index 000000000000..513d3f90e438
>> --- /dev/null
>> +++ b/drivers/crypto/caam/blob_gen.c
>> @@ -0,0 +1,230 @@
>> +// SPDX-License-Identifier: GPL-2.0-only
>> +/*
>> + * Copyright (C) 2015 Pengutronix, Steffen Trumtrar <kernel@pengutronix.de>
>> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
>> + */
>> +
>> +#include <linux/device.h>
>> +#include <soc/fsl/caam-blob.h>
>> +
>> +#include "compat.h"
>> +#include "desc_constr.h"
>> +#include "desc.h"
>> +#include "error.h"
>> +#include "intern.h"
>> +#include "jr.h"
>> +#include "regs.h"
>> +
>> +struct caam_blob_priv {
>> + struct device jrdev;
>> +};
>> +
>> +struct caam_blob_job_result {
>> + int err;
>> + struct completion completion;
>> +};
>> +
>> +static void caam_blob_job_done(struct device *dev, u32 *desc, u32 err, void *context)
>> +{
>> + struct caam_blob_job_result *res = context;
>> + int ecode = 0;
>> +
>> + dev_dbg(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
>> +
>> + if (err)
>> + ecode = caam_jr_strstatus(dev, err);
>> +
>> + res->err = ecode;
>> +
>> + /*
>> + * Upon completion, desc points to a buffer containing a CAAM job
>> + * descriptor which encapsulates data into an externally-storable
>> + * blob.
>> + */
>> + complete(&res->completion);
>> +}
>> +
>> +static u32 *caam_blob_alloc_desc(size_t keymod_len)
>> +{
>> + size_t len;
>> +
>> + /* header + (key mod immediate) + 2x pointers + op */
>> + len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 + CAAM_PTR_SZ_MAX) + 4;
>
> Nit: the amount of magic numbers is overwhelming here. I neither understand
> the statement nor how that comment should help me to understand it.
header = 4
(key mod immediate) = (4 + ALIGN(keymod_len, 4))
2x pointer = 2 * (4 + 4 + CAAM_PTR_SZ_MAX)
op = 4
I haven't heard back from the CAAM maintainers yet since v1. Perhaps now
is a good occasion to chime in? :-)
@Jarkko, could you take a look at patch 5? That's the gist of the series
and I have yet to get maintainer feedback on that one.
Cheers,
Ahmad
>
> BR, Jarkko
>
--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread* RE: [EXT] Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-23 16:20 ` Ahmad Fatoum
@ 2022-02-25 12:20 ` Pankaj Gupta
2022-03-14 15:33 ` Ahmad Fatoum
2022-02-28 12:14 ` Jarkko Sakkinen
1 sibling, 1 reply; 19+ messages in thread
From: Pankaj Gupta @ 2022-02-25 12:20 UTC (permalink / raw)
To: Ahmad Fatoum, Jarkko Sakkinen
Cc: Horia Geanta, Aymen Sghaier, Herbert Xu, David S. Miller, kernel,
David Gstir, tharvey, Matthias Schiffer, James Bottomley,
Mimi Zohar, David Howells, James Morris, Eric Biggers,
Serge E. Hallyn, Jan Luebbe, Richard Weinberger,
Franck Lenormand, Sumit Garg, linux-integrity, keyrings,
linux-crypto, linux-kernel, linux-security-module
> -----Original Message-----
> From: Ahmad Fatoum <a.fatoum@pengutronix.de>
> Sent: Wednesday, February 23, 2022 9:50 PM
> To: Jarkko Sakkinen <jarkko@kernel.org>
> Cc: Horia Geanta <horia.geanta@nxp.com>; Aymen Sghaier
> <aymen.sghaier@nxp.com>; Herbert Xu <herbert@gondor.apana.org.au>;
> David S. Miller <davem@davemloft.net>; kernel@pengutronix.de; David Gstir
> <david@sigma-star.at>; Pankaj Gupta <pankaj.gupta@nxp.com>;
> tharvey@gateworks.com; Matthias Schiffer <matthias.schiffer@ew.tq-
> group.com>; James Bottomley <jejb@linux.ibm.com>; Mimi Zohar
> <zohar@linux.ibm.com>; David Howells <dhowells@redhat.com>; James Morris
> <jmorris@namei.org>; Eric Biggers <ebiggers@kernel.org>; Serge E. Hallyn
> <serge@hallyn.com>; Jan Luebbe <j.luebbe@pengutronix.de>; Richard
> Weinberger <richard@nod.at>; Franck Lenormand
> <franck.lenormand@nxp.com>; Sumit Garg <sumit.garg@linaro.org>; linux-
> integrity@vger.kernel.org; keyrings@vger.kernel.org; linux-
> crypto@vger.kernel.org; linux-kernel@vger.kernel.org; linux-security-
> module@vger.kernel.org
> Subject: [EXT] Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob
> generator
>
> Caution: EXT Email
>
> On 23.02.22 16:41, Jarkko Sakkinen wrote:
> > On Tue, Feb 22, 2022 at 08:58:18PM +0100, Ahmad Fatoum wrote:
> >> The NXP Cryptographic Acceleration and Assurance Module (CAAM) can be
> >> used to protect user-defined data across system reboot:
> >>
> >> - When the system is fused and boots into secure state, the master
> >> key is a unique never-disclosed device-specific key
> >> - random key is encrypted by key derived from master key
> >> - data is encrypted using the random key
> >> - encrypted data and its encrypted random key are stored alongside
> >> - This blob can now be safely stored in non-volatile memory
> >>
> >> On next power-on:
> >> - blob is loaded into CAAM
> >> - CAAM writes decrypted data either into memory or key register
> >>
> >> Add functions to realize encrypting and decrypting into memory
> >> alongside the CAAM driver.
> >>
> >> They will be used in a later commit as a source for the trusted key
> >> seal/unseal mechanism.
> >>
> >> Reviewed-by: David Gstir <david@sigma-star.at>
> >> Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> >> Tested-By: Tim Harvey <tharvey@gateworks.com>
> >> Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> >> Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
> >> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> >> ---
> >> To: "Horia Geantă" <horia.geanta@nxp.com>
> >> To: Aymen Sghaier <aymen.sghaier@nxp.com>
> >> To: Herbert Xu <herbert@gondor.apana.org.au>
> >> To: "David S. Miller" <davem@davemloft.net>
> >> Cc: James Bottomley <jejb@linux.ibm.com>
> >> Cc: Jarkko Sakkinen <jarkko@kernel.org>
> >> Cc: Mimi Zohar <zohar@linux.ibm.com>
> >> Cc: David Howells <dhowells@redhat.com>
> >> Cc: James Morris <jmorris@namei.org>
> >> Cc: Eric Biggers <ebiggers@kernel.org>
> >> Cc: "Serge E. Hallyn" <serge@hallyn.com>
> >> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> >> Cc: David Gstir <david@sigma-star.at>
> >> Cc: Richard Weinberger <richard@nod.at>
> >> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> >> Cc: Sumit Garg <sumit.garg@linaro.org>
> >> Cc: Tim Harvey <tharvey@gateworks.com>
> >> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> >> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> >> Cc: linux-integrity@vger.kernel.org
> >> Cc: keyrings@vger.kernel.org
> >> Cc: linux-crypto@vger.kernel.org
> >> Cc: linux-kernel@vger.kernel.org
> >> Cc: linux-security-module@vger.kernel.org
> >> ---
> >> drivers/crypto/caam/Kconfig | 3 +
> >> drivers/crypto/caam/Makefile | 1 +
> >> drivers/crypto/caam/blob_gen.c | 230
> +++++++++++++++++++++++++++++++++
> >> include/soc/fsl/caam-blob.h | 56 ++++++++
> >> 4 files changed, 290 insertions(+)
> >> create mode 100644 drivers/crypto/caam/blob_gen.c create mode
> >> 100644 include/soc/fsl/caam-blob.h
> >>
> >> diff --git a/drivers/crypto/caam/Kconfig
> >> b/drivers/crypto/caam/Kconfig index 84ea7cba5ee5..ea9f8b1ae981 100644
> >> --- a/drivers/crypto/caam/Kconfig
> >> +++ b/drivers/crypto/caam/Kconfig
> >> @@ -151,6 +151,9 @@ config CRYPTO_DEV_FSL_CAAM_RNG_API
> >> Selecting this will register the SEC4 hardware rng to
> >> the hw_random API for supplying the kernel entropy pool.
> >>
> >> +config CRYPTO_DEV_FSL_CAAM_BLOB_GEN
> >> + bool
> >> +
> >> endif # CRYPTO_DEV_FSL_CAAM_JR
> >>
> >> endif # CRYPTO_DEV_FSL_CAAM
> >> diff --git a/drivers/crypto/caam/Makefile
> >> b/drivers/crypto/caam/Makefile index 3570286eb9ce..25f7ae5a4642
> >> 100644
> >> --- a/drivers/crypto/caam/Makefile
> >> +++ b/drivers/crypto/caam/Makefile
> >> @@ -21,6 +21,7 @@ caam_jr-
> $(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI)
> >> += caamalg_qi.o
> >> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_AHASH_API) += caamhash.o
> >> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_RNG_API) += caamrng.o
> >> caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_PKC_API) += caampkc.o
> >> pkc_desc.o
> >> +caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_BLOB_GEN) += blob_gen.o
> >>
> >> caam-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += qi.o ifneq
> >> ($(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI),)
> >> diff --git a/drivers/crypto/caam/blob_gen.c
> >> b/drivers/crypto/caam/blob_gen.c new file mode 100644 index
> >> 000000000000..513d3f90e438
> >> --- /dev/null
> >> +++ b/drivers/crypto/caam/blob_gen.c
> >> @@ -0,0 +1,230 @@
> >> +// SPDX-License-Identifier: GPL-2.0-only
> >> +/*
> >> + * Copyright (C) 2015 Pengutronix, Steffen Trumtrar
> >> +<kernel@pengutronix.de>
> >> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum
> >> +<kernel@pengutronix.de> */
> >> +
> >> +#include <linux/device.h>
> >> +#include <soc/fsl/caam-blob.h>
> >> +
> >> +#include "compat.h"
> >> +#include "desc_constr.h"
> >> +#include "desc.h"
> >> +#include "error.h"
> >> +#include "intern.h"
> >> +#include "jr.h"
> >> +#include "regs.h"
> >> +
> >> +struct caam_blob_priv {
> >> + struct device jrdev;
> >> +};
> >> +
> >> +struct caam_blob_job_result {
> >> + int err;
> >> + struct completion completion;
> >> +};
> >> +
> >> +static void caam_blob_job_done(struct device *dev, u32 *desc, u32
> >> +err, void *context) {
> >> + struct caam_blob_job_result *res = context;
> >> + int ecode = 0;
> >> +
> >> + dev_dbg(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
> >> +
> >> + if (err)
> >> + ecode = caam_jr_strstatus(dev, err);
> >> +
> >> + res->err = ecode;
> >> +
> >> + /*
> >> + * Upon completion, desc points to a buffer containing a CAAM job
> >> + * descriptor which encapsulates data into an externally-storable
> >> + * blob.
> >> + */
> >> + complete(&res->completion);
> >> +}
> >> +
> >> +static u32 *caam_blob_alloc_desc(size_t keymod_len) {
> >> + size_t len;
> >> +
> >> + /* header + (key mod immediate) + 2x pointers + op */
> >> + len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 +
> >> + CAAM_PTR_SZ_MAX) + 4;
> >
> > Nit: the amount of magic numbers is overwhelming here. I neither
> > understand the statement nor how that comment should help me to
> understand it.
>
> header = 4
> (key mod immediate) = (4 + ALIGN(keymod_len, 4))
> 2x pointer = 2 * (4 + 4 + CAAM_PTR_SZ_MAX)
> op = 4
Instead of the function caam_blob_alloc_desc(), it will be great if the caller functions caam_encap_blob()/caam_encap_blob (), could add local array:
uint32_t desc[CAAM_DESC_BYTES_MAX];
>
> I haven't heard back from the CAAM maintainers yet since v1. Perhaps now is a
> good occasion to chime in? :-)
>
> @Jarkko, could you take a look at patch 5? That's the gist of the series and I
> have yet to get maintainer feedback on that one.
>
> Cheers,
> Ahmad
>
>
> >
> > BR, Jarkko
> >
>
>
> --
> Pengutronix e.K. | |
> Steuerwalder Str. 21 |
> https://eur01.safelinks.protection.outlook.com/?url=http%3A%2F%2Fwww.pen
> gutronix.de%2F&data=04%7C01%7Cpankaj.gupta%40nxp.com%7Cc97e9d4
> aaf304124407908d9f6e87101%7C686ea1d3bc2b4c6fa92cd99c5c301635%7C0%
> 7C0%7C637812300459173929%7CUnknown%7CTWFpbGZsb3d8eyJWIjoiMC4wL
> jAwMDAiLCJQIjoiV2luMzIiLCJBTiI6Ik1haWwiLCJXVCI6Mn0%3D%7C3000&s
> data=CvnfIXR68DPRCaYrOYQKSv2eSBSNSSJYx2BQJee4yLg%3D&reserved=0
> |
> 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [EXT] Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-25 12:20 ` [EXT] " Pankaj Gupta
@ 2022-03-14 15:33 ` Ahmad Fatoum
0 siblings, 0 replies; 19+ messages in thread
From: Ahmad Fatoum @ 2022-03-14 15:33 UTC (permalink / raw)
To: Pankaj Gupta, Jarkko Sakkinen
Cc: David Gstir, Aymen Sghaier, Mimi Zohar, David Howells, keyrings,
Matthias Schiffer, Herbert Xu, Horia Geanta, Richard Weinberger,
James Morris, Eric Biggers, James Bottomley, Serge E. Hallyn,
tharvey, Franck Lenormand, Jan Luebbe, Sumit Garg, linux-kernel,
linux-security-module, linux-crypto, kernel, linux-integrity,
David S. Miller
Hello Pankaj,
On 25.02.22 13:20, Pankaj Gupta wrote:
>>>> +static u32 *caam_blob_alloc_desc(size_t keymod_len) {
>>>> + size_t len;
>>>> +
>>>> + /* header + (key mod immediate) + 2x pointers + op */
>>>> + len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 +
>>>> + CAAM_PTR_SZ_MAX) + 4;
>>>
>>> Nit: the amount of magic numbers is overwhelming here. I neither
>>> understand the statement nor how that comment should help me to
>> understand it.
>>
>> header = 4
>> (key mod immediate) = (4 + ALIGN(keymod_len, 4))
>> 2x pointer = 2 * (4 + 4 + CAAM_PTR_SZ_MAX)
>> op = 4
>
> Instead of the function caam_blob_alloc_desc(), it will be great if the caller functions caam_encap_blob()/caam_encap_blob (), could add local array:
> uint32_t desc[CAAM_DESC_BYTES_MAX];
I just looked into this and placing desc on stack is not possible
as it is used for DMA inside caam_jr_enqueue().
Cheers,
Ahmad
--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-23 16:20 ` Ahmad Fatoum
2022-02-25 12:20 ` [EXT] " Pankaj Gupta
@ 2022-02-28 12:14 ` Jarkko Sakkinen
2022-03-16 16:44 ` Ahmad Fatoum
1 sibling, 1 reply; 19+ messages in thread
From: Jarkko Sakkinen @ 2022-02-28 12:14 UTC (permalink / raw)
To: Ahmad Fatoum
Cc: Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, kernel, David Gstir,
Pankaj Gupta, Tim Harvey, Matthias Schiffer, James Bottomley,
Mimi Zohar, David Howells, James Morris, Eric Biggers,
Serge E. Hallyn, Jan Luebbe, Richard Weinberger,
Franck LENORMAND, Sumit Garg, linux-integrity, keyrings,
linux-crypto, linux-kernel, linux-security-module
On Wed, 2022-02-23 at 17:20 +0100, Ahmad Fatoum wrote:
> On 23.02.22 16:41, Jarkko Sakkinen wrote:
> > On Tue, Feb 22, 2022 at 08:58:18PM +0100, Ahmad Fatoum wrote:
> > > The NXP Cryptographic Acceleration and Assurance Module (CAAM)
> > > can be used to protect user-defined data across system reboot:
> > >
> > > - When the system is fused and boots into secure state, the master
> > > key is a unique never-disclosed device-specific key
> > > - random key is encrypted by key derived from master key
> > > - data is encrypted using the random key
> > > - encrypted data and its encrypted random key are stored alongside
> > > - This blob can now be safely stored in non-volatile memory
> > >
> > > On next power-on:
> > > - blob is loaded into CAAM
> > > - CAAM writes decrypted data either into memory or key register
> > >
> > > Add functions to realize encrypting and decrypting into memory alongside
> > > the CAAM driver.
> > >
> > > They will be used in a later commit as a source for the trusted key
> > > seal/unseal mechanism.
> > >
> > > Reviewed-by: David Gstir <david@sigma-star.at>
> > > Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> > > Tested-By: Tim Harvey <tharvey@gateworks.com>
> > > Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> > > Signed-off-by: Steffen Trumtrar <s.trumtrar@pengutronix.de>
> > > Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> > > ---
> > > To: "Horia Geantă" <horia.geanta@nxp.com>
> > > To: Aymen Sghaier <aymen.sghaier@nxp.com>
> > > To: Herbert Xu <herbert@gondor.apana.org.au>
> > > To: "David S. Miller" <davem@davemloft.net>
> > > Cc: James Bottomley <jejb@linux.ibm.com>
> > > Cc: Jarkko Sakkinen <jarkko@kernel.org>
> > > Cc: Mimi Zohar <zohar@linux.ibm.com>
> > > Cc: David Howells <dhowells@redhat.com>
> > > Cc: James Morris <jmorris@namei.org>
> > > Cc: Eric Biggers <ebiggers@kernel.org>
> > > Cc: "Serge E. Hallyn" <serge@hallyn.com>
> > > Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> > > Cc: David Gstir <david@sigma-star.at>
> > > Cc: Richard Weinberger <richard@nod.at>
> > > Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> > > Cc: Sumit Garg <sumit.garg@linaro.org>
> > > Cc: Tim Harvey <tharvey@gateworks.com>
> > > Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> > > Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> > > Cc: linux-integrity@vger.kernel.org
> > > Cc: keyrings@vger.kernel.org
> > > Cc: linux-crypto@vger.kernel.org
> > > Cc: linux-kernel@vger.kernel.org
> > > Cc: linux-security-module@vger.kernel.org
> > > ---
> > > drivers/crypto/caam/Kconfig | 3 +
> > > drivers/crypto/caam/Makefile | 1 +
> > > drivers/crypto/caam/blob_gen.c | 230 +++++++++++++++++++++++++++++++++
> > > include/soc/fsl/caam-blob.h | 56 ++++++++
> > > 4 files changed, 290 insertions(+)
> > > create mode 100644 drivers/crypto/caam/blob_gen.c
> > > create mode 100644 include/soc/fsl/caam-blob.h
> > >
> > > diff --git a/drivers/crypto/caam/Kconfig b/drivers/crypto/caam/Kconfig
> > > index 84ea7cba5ee5..ea9f8b1ae981 100644
> > > --- a/drivers/crypto/caam/Kconfig
> > > +++ b/drivers/crypto/caam/Kconfig
> > > @@ -151,6 +151,9 @@ config CRYPTO_DEV_FSL_CAAM_RNG_API
> > > Selecting this will register the SEC4 hardware rng to
> > > the hw_random API for supplying the kernel entropy pool.
> > >
> > > +config CRYPTO_DEV_FSL_CAAM_BLOB_GEN
> > > + bool
> > > +
> > > endif # CRYPTO_DEV_FSL_CAAM_JR
> > >
> > > endif # CRYPTO_DEV_FSL_CAAM
> > > diff --git a/drivers/crypto/caam/Makefile b/drivers/crypto/caam/Makefile
> > > index 3570286eb9ce..25f7ae5a4642 100644
> > > --- a/drivers/crypto/caam/Makefile
> > > +++ b/drivers/crypto/caam/Makefile
> > > @@ -21,6 +21,7 @@ caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += caamalg_qi.o
> > > caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_AHASH_API) += caamhash.o
> > > caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_RNG_API) += caamrng.o
> > > caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_PKC_API) += caampkc.o pkc_desc.o
> > > +caam_jr-$(CONFIG_CRYPTO_DEV_FSL_CAAM_BLOB_GEN) += blob_gen.o
> > >
> > > caam-$(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI) += qi.o
> > > ifneq ($(CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_QI),)
> > > diff --git a/drivers/crypto/caam/blob_gen.c b/drivers/crypto/caam/blob_gen.c
> > > new file mode 100644
> > > index 000000000000..513d3f90e438
> > > --- /dev/null
> > > +++ b/drivers/crypto/caam/blob_gen.c
> > > @@ -0,0 +1,230 @@
> > > +// SPDX-License-Identifier: GPL-2.0-only
> > > +/*
> > > + * Copyright (C) 2015 Pengutronix, Steffen Trumtrar <kernel@pengutronix.de>
> > > + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
> > > + */
> > > +
> > > +#include <linux/device.h>
> > > +#include <soc/fsl/caam-blob.h>
> > > +
> > > +#include "compat.h"
> > > +#include "desc_constr.h"
> > > +#include "desc.h"
> > > +#include "error.h"
> > > +#include "intern.h"
> > > +#include "jr.h"
> > > +#include "regs.h"
> > > +
> > > +struct caam_blob_priv {
> > > + struct device jrdev;
> > > +};
> > > +
> > > +struct caam_blob_job_result {
> > > + int err;
> > > + struct completion completion;
> > > +};
> > > +
> > > +static void caam_blob_job_done(struct device *dev, u32 *desc, u32 err, void *context)
> > > +{
> > > + struct caam_blob_job_result *res = context;
> > > + int ecode = 0;
> > > +
> > > + dev_dbg(dev, "%s %d: err 0x%x\n", __func__, __LINE__, err);
> > > +
> > > + if (err)
> > > + ecode = caam_jr_strstatus(dev, err);
> > > +
> > > + res->err = ecode;
> > > +
> > > + /*
> > > + * Upon completion, desc points to a buffer containing a CAAM job
> > > + * descriptor which encapsulates data into an externally-storable
> > > + * blob.
> > > + */
> > > + complete(&res->completion);
> > > +}
> > > +
> > > +static u32 *caam_blob_alloc_desc(size_t keymod_len)
> > > +{
> > > + size_t len;
> > > +
> > > + /* header + (key mod immediate) + 2x pointers + op */
> > > + len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 + CAAM_PTR_SZ_MAX) + 4;
> >
> > Nit: the amount of magic numbers is overwhelming here. I neither understand
> > the statement nor how that comment should help me to understand it.
>
> header = 4
> (key mod immediate) = (4 + ALIGN(keymod_len, 4))
> 2x pointer = 2 * (4 + 4 + CAAM_PTR_SZ_MAX)
> op = 4
Please create a struct with the associated fields instead and then
it is just sizeof that.
BR, Jarkko
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator
2022-02-28 12:14 ` Jarkko Sakkinen
@ 2022-03-16 16:44 ` Ahmad Fatoum
0 siblings, 0 replies; 19+ messages in thread
From: Ahmad Fatoum @ 2022-03-16 16:44 UTC (permalink / raw)
To: Jarkko Sakkinen
Cc: Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, kernel, David Gstir,
Pankaj Gupta, Tim Harvey, Matthias Schiffer, James Bottomley,
Mimi Zohar, David Howells, James Morris, Eric Biggers,
Serge E. Hallyn, Jan Luebbe, Richard Weinberger,
Franck LENORMAND, Sumit Garg, linux-integrity, keyrings,
linux-crypto, linux-kernel, linux-security-module
Hello Jarkko,
On 28.02.22 13:14, Jarkko Sakkinen wrote:
> On Wed, 2022-02-23 at 17:20 +0100, Ahmad Fatoum wrote:
>> On 23.02.22 16:41, Jarkko Sakkinen wrote:
>>> On Tue, Feb 22, 2022 at 08:58:18PM +0100, Ahmad Fatoum wrote:
>>>> + /* header + (key mod immediate) + 2x pointers + op */
>>>> + len = 4 + (4 + ALIGN(keymod_len, 4)) + 2*(4 + 4 + CAAM_PTR_SZ_MAX) + 4;
>>>
>>> Nit: the amount of magic numbers is overwhelming here. I neither understand
>>> the statement nor how that comment should help me to understand it.
>>
>> header = 4
>> (key mod immediate) = (4 + ALIGN(keymod_len, 4))
>> 2x pointer = 2 * (4 + 4 + CAAM_PTR_SZ_MAX)
>> op = 4
>
> Please create a struct with the associated fields instead and then
> it is just sizeof that.
The CAAM descriptor construction code writes the current length
to the first word and then macros are used to append fields to
the descriptor while incrementing the length. The key modifier
is in the middle of the descriptor, so this isn't representable
as a C struct without using VLAs, which are banned in the kernel.
Even if it worked, it's arguably not good style to define a struct
just to compute the size and then cast it to a u32 * to use the
same macros all other CAAM code uses.
I thought this over a bit and figured that we don't really need to
compute the length dynamically as it's at most 44 or 52 bytes
(depending on DMA address width) anyway, so we can just use a fixed
value. I still keep the addition, because I believe there is a value
in seeing how we arrive at the 44 or 52 bytes instead of just hardcoding
it.
Just sent out v6 with these changes. Let me know what you think.
Cheers,
Ahmad
--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys
2022-02-22 19:58 [PATCH v5 0/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
` (3 preceding siblings ...)
2022-02-22 19:58 ` [PATCH v5 4/5] crypto: caam - add in-kernel interface for blob generator Ahmad Fatoum
@ 2022-02-22 19:58 ` Ahmad Fatoum
2022-02-25 12:43 ` [EXT] " Pankaj Gupta
2022-03-02 4:37 ` Pankaj Gupta
4 siblings, 2 replies; 19+ messages in thread
From: Ahmad Fatoum @ 2022-02-22 19:58 UTC (permalink / raw)
To: Jonathan Corbet, David Howells, Jarkko Sakkinen, James Bottomley,
Mimi Zohar
Cc: kernel, David Gstir, Tim Harvey, Matthias Schiffer, Ahmad Fatoum,
James Morris, Serge E. Hallyn, Horia Geantă,
Aymen Sghaier, Herbert Xu, David S. Miller, Eric Biggers,
Jan Luebbe, Richard Weinberger, Franck LENORMAND, Sumit Garg,
Pankaj Gupta, keyrings, linux-crypto, linux-doc, linux-integrity,
linux-kernel, linux-security-module
The Cryptographic Acceleration and Assurance Module (CAAM) is an IP core
built into many newer i.MX and QorIQ SoCs by NXP.
The CAAM does crypto acceleration, hardware number generation and
has a blob mechanism for encapsulation/decapsulation of sensitive material.
This blob mechanism depends on a device specific random 256-bit One Time
Programmable Master Key that is fused in each SoC at manufacturing
time. This key is unreadable and can only be used by the CAAM for AES
encryption/decryption of user data.
This makes it a suitable backend (source) for kernel trusted keys.
Previous commits generalized trusted keys to support multiple backends
and added an API to access the CAAM blob mechanism. Based on these,
provide the necessary glue to use the CAAM for trusted keys.
Reviewed-by: David Gstir <david@sigma-star.at>
Tested-By: Tim Harvey <tharvey@gateworks.com>
Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
To: Jonathan Corbet <corbet@lwn.net>
To: David Howells <dhowells@redhat.com>
To: Jarkko Sakkinen <jarkko@kernel.org>
To: James Bottomley <jejb@linux.ibm.com>
To: Mimi Zohar <zohar@linux.ibm.com>
Cc: James Morris <jmorris@namei.org>
Cc: "Serge E. Hallyn" <serge@hallyn.com>
Cc: "Horia Geantă" <horia.geanta@nxp.com>
Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: Jan Luebbe <j.luebbe@pengutronix.de>
Cc: David Gstir <david@sigma-star.at>
Cc: Richard Weinberger <richard@nod.at>
Cc: Franck LENORMAND <franck.lenormand@nxp.com>
Cc: Sumit Garg <sumit.garg@linaro.org>
Cc: Tim Harvey <tharvey@gateworks.com>
Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
Cc: keyrings@vger.kernel.org
Cc: linux-crypto@vger.kernel.org
Cc: linux-doc@vger.kernel.org
Cc: linux-integrity@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-security-module@vger.kernel.org
---
.../admin-guide/kernel-parameters.txt | 1 +
.../security/keys/trusted-encrypted.rst | 40 +++++++++-
MAINTAINERS | 9 +++
include/keys/trusted_caam.h | 11 +++
security/keys/trusted-keys/Kconfig | 11 ++-
security/keys/trusted-keys/Makefile | 2 +
security/keys/trusted-keys/trusted_caam.c | 74 +++++++++++++++++++
security/keys/trusted-keys/trusted_core.c | 6 +-
8 files changed, 151 insertions(+), 3 deletions(-)
create mode 100644 include/keys/trusted_caam.h
create mode 100644 security/keys/trusted-keys/trusted_caam.c
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 844c883ca9d8..9e7ef4c6585d 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -5875,6 +5875,7 @@
sources:
- "tpm"
- "tee"
+ - "caam"
If not specified then it defaults to iterating through
the trust source list starting with TPM and assigns the
first trust source as a backend which is initialized
diff --git a/Documentation/security/keys/trusted-encrypted.rst b/Documentation/security/keys/trusted-encrypted.rst
index 99cf34d7c025..ed60c48cb692 100644
--- a/Documentation/security/keys/trusted-encrypted.rst
+++ b/Documentation/security/keys/trusted-encrypted.rst
@@ -35,6 +35,13 @@ safe.
Rooted to Hardware Unique Key (HUK) which is generally burnt in on-chip
fuses and is accessible to TEE only.
+ (3) CAAM (Cryptographic Acceleration and Assurance Module: IP on NXP SoCs)
+
+ When High Assurance Boot (HAB) is enabled and the CAAM is in secure
+ mode, trust is rooted to the OTPMK, a never-disclosed 256-bit key
+ randomly generated and fused into each SoC at manufacturing time.
+ Otherwise, a common fixed test key is used instead.
+
* Execution isolation
(1) TPM
@@ -46,6 +53,10 @@ safe.
Customizable set of operations running in isolated execution
environment verified via Secure/Trusted boot process.
+ (3) CAAM
+
+ Fixed set of operations running in isolated execution environment.
+
* Optional binding to platform integrity state
(1) TPM
@@ -63,6 +74,11 @@ safe.
Relies on Secure/Trusted boot process for platform integrity. It can
be extended with TEE based measured boot process.
+ (3) CAAM
+
+ Relies on the High Assurance Boot (HAB) mechanism of NXP SoCs
+ for platform integrity.
+
* Interfaces and APIs
(1) TPM
@@ -74,10 +90,13 @@ safe.
TEEs have well-documented, standardized client interface and APIs. For
more details refer to ``Documentation/staging/tee.rst``.
+ (3) CAAM
+
+ Interface is specific to silicon vendor.
* Threat model
- The strength and appropriateness of a particular TPM or TEE for a given
+ The strength and appropriateness of a particular trust source for a given
purpose must be assessed when using them to protect security-relevant data.
@@ -104,6 +123,12 @@ selected trust source:
from platform specific hardware RNG or a software based Fortuna CSPRNG
which can be seeded via multiple entropy sources.
+ * CAAM: Kernel RNG
+
+ The normal kernel random number generator is used. To seed it from the
+ CAAM HWRNG, enable CRYPTO_DEV_FSL_CAAM_RNG_API and ensure the device
+ is probed.
+
Users may override this by specifying ``trusted.rng=kernel`` on the kernel
command-line to override the used RNG with the kernel's random number pool.
@@ -192,6 +217,19 @@ Usage::
specific to TEE device implementation. The key length for new keys is always
in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
+Trusted Keys usage: CAAM
+------------------------
+
+Usage::
+
+ keyctl add trusted name "new keylen" ring
+ keyctl add trusted name "load hex_blob" ring
+ keyctl print keyid
+
+"keyctl print" returns an ASCII hex copy of the sealed key, which is in format
+specific to CAAM device implementation. The key length for new keys is always
+in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
+
Encrypted Keys usage
--------------------
diff --git a/MAINTAINERS b/MAINTAINERS
index f670002134e0..6eca4476bb76 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -10655,6 +10655,15 @@ S: Supported
F: include/keys/trusted_tee.h
F: security/keys/trusted-keys/trusted_tee.c
+KEYS-TRUSTED-CAAM
+M: Ahmad Fatoum <a.fatoum@pengutronix.de>
+R: Pengutronix Kernel Team <kernel@pengutronix.de>
+L: linux-integrity@vger.kernel.org
+L: keyrings@vger.kernel.org
+S: Maintained
+F: include/keys/trusted_caam.h
+F: security/keys/trusted-keys/trusted_caam.c
+
KEYS/KEYRINGS
M: David Howells <dhowells@redhat.com>
M: Jarkko Sakkinen <jarkko@kernel.org>
diff --git a/include/keys/trusted_caam.h b/include/keys/trusted_caam.h
new file mode 100644
index 000000000000..2fba0996b0b0
--- /dev/null
+++ b/include/keys/trusted_caam.h
@@ -0,0 +1,11 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
+ */
+
+#ifndef __CAAM_TRUSTED_KEY_H
+#define __CAAM_TRUSTED_KEY_H
+
+extern struct trusted_key_ops caam_trusted_key_ops;
+
+#endif
diff --git a/security/keys/trusted-keys/Kconfig b/security/keys/trusted-keys/Kconfig
index fc4abd581abb..dbfdd8536468 100644
--- a/security/keys/trusted-keys/Kconfig
+++ b/security/keys/trusted-keys/Kconfig
@@ -24,6 +24,15 @@ config TRUSTED_KEYS_TEE
Enable use of the Trusted Execution Environment (TEE) as trusted
key backend.
-if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
+config TRUSTED_KEYS_CAAM
+ bool "CAAM-based trusted keys"
+ depends on CRYPTO_DEV_FSL_CAAM_JR >= TRUSTED_KEYS
+ select CRYPTO_DEV_FSL_CAAM_BLOB_GEN
+ default y
+ help
+ Enable use of NXP's Cryptographic Accelerator and Assurance Module
+ (CAAM) as trusted key backend.
+
+if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE && !TRUSTED_KEYS_CAAM
comment "No trust source selected!"
endif
diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-keys/Makefile
index 2e2371eae4d5..735aa0bc08ef 100644
--- a/security/keys/trusted-keys/Makefile
+++ b/security/keys/trusted-keys/Makefile
@@ -12,3 +12,5 @@ trusted-$(CONFIG_TRUSTED_KEYS_TPM) += trusted_tpm2.o
trusted-$(CONFIG_TRUSTED_KEYS_TPM) += tpm2key.asn1.o
trusted-$(CONFIG_TRUSTED_KEYS_TEE) += trusted_tee.o
+
+trusted-$(CONFIG_TRUSTED_KEYS_CAAM) += trusted_caam.o
diff --git a/security/keys/trusted-keys/trusted_caam.c b/security/keys/trusted-keys/trusted_caam.c
new file mode 100644
index 000000000000..066f08d6eb2c
--- /dev/null
+++ b/security/keys/trusted-keys/trusted_caam.c
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
+ */
+
+#include <keys/trusted_caam.h>
+#include <keys/trusted-type.h>
+#include <linux/build_bug.h>
+#include <linux/key-type.h>
+#include <soc/fsl/caam-blob.h>
+
+static struct caam_blob_priv *blobifier;
+
+#define KEYMOD "SECURE_KEY"
+
+static_assert(MAX_KEY_SIZE + CAAM_BLOB_OVERHEAD <= CAAM_BLOB_MAX_LEN);
+static_assert(MAX_BLOB_SIZE <= CAAM_BLOB_MAX_LEN);
+
+static int trusted_caam_seal(struct trusted_key_payload *p, char *datablob)
+{
+ int length = p->key_len + CAAM_BLOB_OVERHEAD;
+ int ret;
+
+ ret = caam_encap_blob(blobifier, KEYMOD, p->key, p->blob, length);
+ if (ret)
+ return ret;
+
+ p->blob_len = length;
+ return 0;
+}
+
+static int trusted_caam_unseal(struct trusted_key_payload *p, char *datablob)
+{
+ int length = p->blob_len;
+ int ret;
+
+ ret = caam_decap_blob(blobifier, KEYMOD, p->blob, p->key, length);
+ if (ret)
+ return ret;
+
+ p->key_len = length - CAAM_BLOB_OVERHEAD;
+ return 0;
+}
+
+static int trusted_caam_init(void)
+{
+ int ret;
+
+ blobifier = caam_blob_gen_init();
+ if (IS_ERR(blobifier)) {
+ pr_err("Job Ring Device allocation for transform failed\n");
+ return PTR_ERR(blobifier);
+ }
+
+ ret = register_key_type(&key_type_trusted);
+ if (ret)
+ caam_blob_gen_exit(blobifier);
+
+ return ret;
+}
+
+static void trusted_caam_exit(void)
+{
+ unregister_key_type(&key_type_trusted);
+ caam_blob_gen_exit(blobifier);
+}
+
+struct trusted_key_ops caam_trusted_key_ops = {
+ .migratable = 0, /* non-migratable */
+ .init = trusted_caam_init,
+ .seal = trusted_caam_seal,
+ .unseal = trusted_caam_unseal,
+ .exit = trusted_caam_exit,
+};
diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trusted-keys/trusted_core.c
index 9235fb7d0ec9..640434cd437a 100644
--- a/security/keys/trusted-keys/trusted_core.c
+++ b/security/keys/trusted-keys/trusted_core.c
@@ -9,6 +9,7 @@
#include <keys/user-type.h>
#include <keys/trusted-type.h>
#include <keys/trusted_tee.h>
+#include <keys/trusted_caam.h>
#include <keys/trusted_tpm.h>
#include <linux/capability.h>
#include <linux/err.h>
@@ -29,7 +30,7 @@ MODULE_PARM_DESC(rng, "Select trusted key RNG");
static char *trusted_key_source;
module_param_named(source, trusted_key_source, charp, 0);
-MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
+MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee or caam)");
static const struct trusted_key_source trusted_key_sources[] = {
#if defined(CONFIG_TRUSTED_KEYS_TPM)
@@ -38,6 +39,9 @@ static const struct trusted_key_source trusted_key_sources[] = {
#if defined(CONFIG_TRUSTED_KEYS_TEE)
{ "tee", &trusted_key_tee_ops },
#endif
+#if defined(CONFIG_TRUSTED_KEYS_CAAM)
+ { "caam", &caam_trusted_key_ops },
+#endif
};
DEFINE_STATIC_CALL_NULL(trusted_key_init, *trusted_key_sources[0].ops->init);
--
2.30.2
^ permalink raw reply related [flat|nested] 19+ messages in thread* RE: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys
2022-02-22 19:58 ` [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
@ 2022-02-25 12:43 ` Pankaj Gupta
2022-03-02 4:37 ` Pankaj Gupta
1 sibling, 0 replies; 19+ messages in thread
From: Pankaj Gupta @ 2022-02-25 12:43 UTC (permalink / raw)
To: Ahmad Fatoum, Jonathan Corbet, David Howells, Jarkko Sakkinen,
James Bottomley, Mimi Zohar
Cc: kernel, David Gstir, tharvey, Matthias Schiffer, James Morris,
Serge E. Hallyn, Horia Geanta, Aymen Sghaier, Herbert Xu,
David S. Miller, Eric Biggers, Jan Luebbe, Richard Weinberger,
Franck Lenormand, Sumit Garg, keyrings, linux-crypto, linux-doc,
linux-integrity, linux-kernel, linux-security-module
Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> -----Original Message-----
> From: Ahmad Fatoum <a.fatoum@pengutronix.de>
> Sent: Wednesday, February 23, 2022 1:28 AM
> To: Jonathan Corbet <corbet@lwn.net>; David Howells
> <dhowells@redhat.com>; Jarkko Sakkinen <jarkko@kernel.org>; James
> Bottomley <jejb@linux.ibm.com>; Mimi Zohar <zohar@linux.ibm.com>
> Cc: kernel@pengutronix.de; David Gstir <david@sigma-star.at>;
> tharvey@gateworks.com; Matthias Schiffer <matthias.schiffer@ew.tq-
> group.com>; Ahmad Fatoum <a.fatoum@pengutronix.de>; James Morris
> <jmorris@namei.org>; Serge E. Hallyn <serge@hallyn.com>; Horia Geanta
> <horia.geanta@nxp.com>; Aymen Sghaier <aymen.sghaier@nxp.com>; Herbert
> Xu <herbert@gondor.apana.org.au>; David S. Miller <davem@davemloft.net>;
> Eric Biggers <ebiggers@kernel.org>; Jan Luebbe <j.luebbe@pengutronix.de>;
> Richard Weinberger <richard@nod.at>; Franck Lenormand
> <franck.lenormand@nxp.com>; Sumit Garg <sumit.garg@linaro.org>; Pankaj
> Gupta <pankaj.gupta@nxp.com>; keyrings@vger.kernel.org; linux-
> crypto@vger.kernel.org; linux-doc@vger.kernel.org; linux-
> integrity@vger.kernel.org; linux-kernel@vger.kernel.org; linux-security-
> module@vger.kernel.org
> Subject: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-
> based trusted keys
>
> Caution: EXT Email
>
> The Cryptographic Acceleration and Assurance Module (CAAM) is an IP core built
> into many newer i.MX and QorIQ SoCs by NXP.
>
> The CAAM does crypto acceleration, hardware number generation and has a
> blob mechanism for encapsulation/decapsulation of sensitive material.
>
> This blob mechanism depends on a device specific random 256-bit One Time
> Programmable Master Key that is fused in each SoC at manufacturing time. This
> key is unreadable and can only be used by the CAAM for AES
> encryption/decryption of user data.
>
> This makes it a suitable backend (source) for kernel trusted keys.
>
> Previous commits generalized trusted keys to support multiple backends and
> added an API to access the CAAM blob mechanism. Based on these, provide the
> necessary glue to use the CAAM for trusted keys.
>
> Reviewed-by: David Gstir <david@sigma-star.at>
> Tested-By: Tim Harvey <tharvey@gateworks.com>
> Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> ---
> To: Jonathan Corbet <corbet@lwn.net>
> To: David Howells <dhowells@redhat.com>
> To: Jarkko Sakkinen <jarkko@kernel.org>
> To: James Bottomley <jejb@linux.ibm.com>
> To: Mimi Zohar <zohar@linux.ibm.com>
> Cc: James Morris <jmorris@namei.org>
> Cc: "Serge E. Hallyn" <serge@hallyn.com>
> Cc: "Horia Geantă" <horia.geanta@nxp.com>
> Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> Cc: Herbert Xu <herbert@gondor.apana.org.au>
> Cc: "David S. Miller" <davem@davemloft.net>
> Cc: Eric Biggers <ebiggers@kernel.org>
> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> Cc: David Gstir <david@sigma-star.at>
> Cc: Richard Weinberger <richard@nod.at>
> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> Cc: Sumit Garg <sumit.garg@linaro.org>
> Cc: Tim Harvey <tharvey@gateworks.com>
> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> Cc: keyrings@vger.kernel.org
> Cc: linux-crypto@vger.kernel.org
> Cc: linux-doc@vger.kernel.org
> Cc: linux-integrity@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> Cc: linux-security-module@vger.kernel.org
> ---
> .../admin-guide/kernel-parameters.txt | 1 +
> .../security/keys/trusted-encrypted.rst | 40 +++++++++-
> MAINTAINERS | 9 +++
> include/keys/trusted_caam.h | 11 +++
> security/keys/trusted-keys/Kconfig | 11 ++-
> security/keys/trusted-keys/Makefile | 2 +
> security/keys/trusted-keys/trusted_caam.c | 74 +++++++++++++++++++
> security/keys/trusted-keys/trusted_core.c | 6 +-
> 8 files changed, 151 insertions(+), 3 deletions(-) create mode 100644
> include/keys/trusted_caam.h create mode 100644 security/keys/trusted-
> keys/trusted_caam.c
>
> diff --git a/Documentation/admin-guide/kernel-parameters.txt
> b/Documentation/admin-guide/kernel-parameters.txt
> index 844c883ca9d8..9e7ef4c6585d 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -5875,6 +5875,7 @@
> sources:
> - "tpm"
> - "tee"
> + - "caam"
> If not specified then it defaults to iterating through
> the trust source list starting with TPM and assigns the
> first trust source as a backend which is initialized diff --git
> a/Documentation/security/keys/trusted-encrypted.rst
> b/Documentation/security/keys/trusted-encrypted.rst
> index 99cf34d7c025..ed60c48cb692 100644
> --- a/Documentation/security/keys/trusted-encrypted.rst
> +++ b/Documentation/security/keys/trusted-encrypted.rst
> @@ -35,6 +35,13 @@ safe.
> Rooted to Hardware Unique Key (HUK) which is generally burnt in on-chip
> fuses and is accessible to TEE only.
>
> + (3) CAAM (Cryptographic Acceleration and Assurance Module: IP on
> + NXP SoCs)
> +
> + When High Assurance Boot (HAB) is enabled and the CAAM is in secure
> + mode, trust is rooted to the OTPMK, a never-disclosed 256-bit key
> + randomly generated and fused into each SoC at manufacturing time.
> + Otherwise, a common fixed test key is used instead.
> +
> * Execution isolation
>
> (1) TPM
> @@ -46,6 +53,10 @@ safe.
> Customizable set of operations running in isolated execution
> environment verified via Secure/Trusted boot process.
>
> + (3) CAAM
> +
> + Fixed set of operations running in isolated execution environment.
> +
> * Optional binding to platform integrity state
>
> (1) TPM
> @@ -63,6 +74,11 @@ safe.
> Relies on Secure/Trusted boot process for platform integrity. It can
> be extended with TEE based measured boot process.
>
> + (3) CAAM
> +
> + Relies on the High Assurance Boot (HAB) mechanism of NXP SoCs
> + for platform integrity.
> +
> * Interfaces and APIs
>
> (1) TPM
> @@ -74,10 +90,13 @@ safe.
> TEEs have well-documented, standardized client interface and APIs. For
> more details refer to ``Documentation/staging/tee.rst``.
>
> + (3) CAAM
> +
> + Interface is specific to silicon vendor.
>
> * Threat model
>
> - The strength and appropriateness of a particular TPM or TEE for a given
> + The strength and appropriateness of a particular trust source for
> + a given
> purpose must be assessed when using them to protect security-relevant data.
>
>
> @@ -104,6 +123,12 @@ selected trust source:
> from platform specific hardware RNG or a software based Fortuna CSPRNG
> which can be seeded via multiple entropy sources.
>
> + * CAAM: Kernel RNG
> +
> + The normal kernel random number generator is used. To seed it from the
> + CAAM HWRNG, enable CRYPTO_DEV_FSL_CAAM_RNG_API and ensure the
> device
> + is probed.
> +
> Users may override this by specifying ``trusted.rng=kernel`` on the kernel
> command-line to override the used RNG with the kernel's random number pool.
>
> @@ -192,6 +217,19 @@ Usage::
> specific to TEE device implementation. The key length for new keys is always in
> bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
>
> +Trusted Keys usage: CAAM
> +------------------------
> +
> +Usage::
> +
> + keyctl add trusted name "new keylen" ring
> + keyctl add trusted name "load hex_blob" ring
> + keyctl print keyid
> +
> +"keyctl print" returns an ASCII hex copy of the sealed key, which is in
> +format specific to CAAM device implementation. The key length for new
> +keys is always in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
> +
> Encrypted Keys usage
> --------------------
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index f670002134e0..6eca4476bb76 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -10655,6 +10655,15 @@ S: Supported
> F: include/keys/trusted_tee.h
> F: security/keys/trusted-keys/trusted_tee.c
>
> +KEYS-TRUSTED-CAAM
> +M: Ahmad Fatoum <a.fatoum@pengutronix.de>
> +R: Pengutronix Kernel Team <kernel@pengutronix.de>
> +L: linux-integrity@vger.kernel.org
> +L: keyrings@vger.kernel.org
> +S: Maintained
> +F: include/keys/trusted_caam.h
> +F: security/keys/trusted-keys/trusted_caam.c
> +
> KEYS/KEYRINGS
> M: David Howells <dhowells@redhat.com>
> M: Jarkko Sakkinen <jarkko@kernel.org>
> diff --git a/include/keys/trusted_caam.h b/include/keys/trusted_caam.h new file
> mode 100644 index 000000000000..2fba0996b0b0
> --- /dev/null
> +++ b/include/keys/trusted_caam.h
> @@ -0,0 +1,11 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
> +*/
> +
> +#ifndef __CAAM_TRUSTED_KEY_H
> +#define __CAAM_TRUSTED_KEY_H
> +
> +extern struct trusted_key_ops caam_trusted_key_ops;
> +
> +#endif
> diff --git a/security/keys/trusted-keys/Kconfig b/security/keys/trusted-
> keys/Kconfig
> index fc4abd581abb..dbfdd8536468 100644
> --- a/security/keys/trusted-keys/Kconfig
> +++ b/security/keys/trusted-keys/Kconfig
> @@ -24,6 +24,15 @@ config TRUSTED_KEYS_TEE
> Enable use of the Trusted Execution Environment (TEE) as trusted
> key backend.
>
> -if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
> +config TRUSTED_KEYS_CAAM
> + bool "CAAM-based trusted keys"
> + depends on CRYPTO_DEV_FSL_CAAM_JR >= TRUSTED_KEYS
> + select CRYPTO_DEV_FSL_CAAM_BLOB_GEN
> + default y
> + help
> + Enable use of NXP's Cryptographic Accelerator and Assurance Module
> + (CAAM) as trusted key backend.
> +
> +if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE && !TRUSTED_KEYS_CAAM
> comment "No trust source selected!"
> endif
> diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-
> keys/Makefile
> index 2e2371eae4d5..735aa0bc08ef 100644
> --- a/security/keys/trusted-keys/Makefile
> +++ b/security/keys/trusted-keys/Makefile
> @@ -12,3 +12,5 @@ trusted-$(CONFIG_TRUSTED_KEYS_TPM) +=
> trusted_tpm2.o
> trusted-$(CONFIG_TRUSTED_KEYS_TPM) += tpm2key.asn1.o
>
> trusted-$(CONFIG_TRUSTED_KEYS_TEE) += trusted_tee.o
> +
> +trusted-$(CONFIG_TRUSTED_KEYS_CAAM) += trusted_caam.o
> diff --git a/security/keys/trusted-keys/trusted_caam.c b/security/keys/trusted-
> keys/trusted_caam.c
> new file mode 100644
> index 000000000000..066f08d6eb2c
> --- /dev/null
> +++ b/security/keys/trusted-keys/trusted_caam.c
> @@ -0,0 +1,74 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
> +*/
> +
> +#include <keys/trusted_caam.h>
> +#include <keys/trusted-type.h>
> +#include <linux/build_bug.h>
> +#include <linux/key-type.h>
> +#include <soc/fsl/caam-blob.h>
> +
> +static struct caam_blob_priv *blobifier;
> +
> +#define KEYMOD "SECURE_KEY"
> +
> +static_assert(MAX_KEY_SIZE + CAAM_BLOB_OVERHEAD <=
> CAAM_BLOB_MAX_LEN);
> +static_assert(MAX_BLOB_SIZE <= CAAM_BLOB_MAX_LEN);
> +
> +static int trusted_caam_seal(struct trusted_key_payload *p, char
> +*datablob) {
> + int length = p->key_len + CAAM_BLOB_OVERHEAD;
> + int ret;
> +
> + ret = caam_encap_blob(blobifier, KEYMOD, p->key, p->blob, length);
> + if (ret)
> + return ret;
> +
> + p->blob_len = length;
> + return 0;
> +}
> +
> +static int trusted_caam_unseal(struct trusted_key_payload *p, char
> +*datablob) {
> + int length = p->blob_len;
> + int ret;
> +
> + ret = caam_decap_blob(blobifier, KEYMOD, p->blob, p->key, length);
> + if (ret)
> + return ret;
> +
> + p->key_len = length - CAAM_BLOB_OVERHEAD;
> + return 0;
> +}
> +
> +static int trusted_caam_init(void)
> +{
> + int ret;
> +
> + blobifier = caam_blob_gen_init();
> + if (IS_ERR(blobifier)) {
> + pr_err("Job Ring Device allocation for transform failed\n");
> + return PTR_ERR(blobifier);
> + }
> +
> + ret = register_key_type(&key_type_trusted);
> + if (ret)
> + caam_blob_gen_exit(blobifier);
> +
> + return ret;
> +}
> +
> +static void trusted_caam_exit(void)
> +{
> + unregister_key_type(&key_type_trusted);
> + caam_blob_gen_exit(blobifier);
> +}
> +
> +struct trusted_key_ops caam_trusted_key_ops = {
> + .migratable = 0, /* non-migratable */
> + .init = trusted_caam_init,
> + .seal = trusted_caam_seal,
> + .unseal = trusted_caam_unseal,
> + .exit = trusted_caam_exit,
> +};
> diff --git a/security/keys/trusted-keys/trusted_core.c b/security/keys/trusted-
> keys/trusted_core.c
> index 9235fb7d0ec9..640434cd437a 100644
> --- a/security/keys/trusted-keys/trusted_core.c
> +++ b/security/keys/trusted-keys/trusted_core.c
> @@ -9,6 +9,7 @@
> #include <keys/user-type.h>
> #include <keys/trusted-type.h>
> #include <keys/trusted_tee.h>
> +#include <keys/trusted_caam.h>
> #include <keys/trusted_tpm.h>
> #include <linux/capability.h>
> #include <linux/err.h>
> @@ -29,7 +30,7 @@ MODULE_PARM_DESC(rng, "Select trusted key RNG");
>
> static char *trusted_key_source;
> module_param_named(source, trusted_key_source, charp, 0); -
> MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
> +MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee or
> +caam)");
>
> static const struct trusted_key_source trusted_key_sources[] = { #if
> defined(CONFIG_TRUSTED_KEYS_TPM) @@ -38,6 +39,9 @@ static const struct
> trusted_key_source trusted_key_sources[] = { #if
> defined(CONFIG_TRUSTED_KEYS_TEE)
> { "tee", &trusted_key_tee_ops }, #endif
> +#if defined(CONFIG_TRUSTED_KEYS_CAAM)
> + { "caam", &caam_trusted_key_ops }, #endif
> };
>
> DEFINE_STATIC_CALL_NULL(trusted_key_init, *trusted_key_sources[0].ops-
> >init);
> --
> 2.30.2
^ permalink raw reply [flat|nested] 19+ messages in thread* RE: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys
2022-02-22 19:58 ` [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys Ahmad Fatoum
2022-02-25 12:43 ` [EXT] " Pankaj Gupta
@ 2022-03-02 4:37 ` Pankaj Gupta
2022-03-07 4:48 ` Pankaj Gupta
1 sibling, 1 reply; 19+ messages in thread
From: Pankaj Gupta @ 2022-03-02 4:37 UTC (permalink / raw)
To: Ahmad Fatoum, Jonathan Corbet, David Howells, Jarkko Sakkinen,
James Bottomley, Mimi Zohar
Cc: kernel, David Gstir, tharvey, Matthias Schiffer, James Morris,
Serge E. Hallyn, Horia Geanta, Aymen Sghaier, Herbert Xu,
David S. Miller, Eric Biggers, Jan Luebbe, Richard Weinberger,
Franck Lenormand, Sumit Garg, keyrings, linux-crypto, linux-doc,
linux-integrity, linux-kernel, linux-security-module
Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
> -----Original Message-----
> From: Ahmad Fatoum <a.fatoum@pengutronix.de>
> Sent: Wednesday, February 23, 2022 1:28 AM
> To: Jonathan Corbet <corbet@lwn.net>; David Howells
> <dhowells@redhat.com>; Jarkko Sakkinen <jarkko@kernel.org>; James
> Bottomley <jejb@linux.ibm.com>; Mimi Zohar <zohar@linux.ibm.com>
> Cc: kernel@pengutronix.de; David Gstir <david@sigma-star.at>;
> tharvey@gateworks.com; Matthias Schiffer <matthias.schiffer@ew.tq-
> group.com>; Ahmad Fatoum <a.fatoum@pengutronix.de>; James Morris
> <jmorris@namei.org>; Serge E. Hallyn <serge@hallyn.com>; Horia Geanta
> <horia.geanta@nxp.com>; Aymen Sghaier <aymen.sghaier@nxp.com>;
> Herbert Xu <herbert@gondor.apana.org.au>; David S. Miller
> <davem@davemloft.net>; Eric Biggers <ebiggers@kernel.org>; Jan Luebbe
> <j.luebbe@pengutronix.de>; Richard Weinberger <richard@nod.at>; Franck
> Lenormand <franck.lenormand@nxp.com>; Sumit Garg
> <sumit.garg@linaro.org>; Pankaj Gupta <pankaj.gupta@nxp.com>;
> keyrings@vger.kernel.org; linux-crypto@vger.kernel.org; linux-
> doc@vger.kernel.org; linux-integrity@vger.kernel.org; linux-
> kernel@vger.kernel.org; linux-security-module@vger.kernel.org
> Subject: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP
> CAAM-based trusted keys
>
> Caution: EXT Email
>
> The Cryptographic Acceleration and Assurance Module (CAAM) is an IP core
> built into many newer i.MX and QorIQ SoCs by NXP.
>
> The CAAM does crypto acceleration, hardware number generation and has a
> blob mechanism for encapsulation/decapsulation of sensitive material.
>
> This blob mechanism depends on a device specific random 256-bit One Time
> Programmable Master Key that is fused in each SoC at manufacturing time.
> This key is unreadable and can only be used by the CAAM for AES
> encryption/decryption of user data.
>
> This makes it a suitable backend (source) for kernel trusted keys.
>
> Previous commits generalized trusted keys to support multiple backends and
> added an API to access the CAAM blob mechanism. Based on these, provide
> the necessary glue to use the CAAM for trusted keys.
>
> Reviewed-by: David Gstir <david@sigma-star.at>
> Tested-By: Tim Harvey <tharvey@gateworks.com>
> Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> ---
> To: Jonathan Corbet <corbet@lwn.net>
> To: David Howells <dhowells@redhat.com>
> To: Jarkko Sakkinen <jarkko@kernel.org>
> To: James Bottomley <jejb@linux.ibm.com>
> To: Mimi Zohar <zohar@linux.ibm.com>
> Cc: James Morris <jmorris@namei.org>
> Cc: "Serge E. Hallyn" <serge@hallyn.com>
> Cc: "Horia Geantă" <horia.geanta@nxp.com>
> Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> Cc: Herbert Xu <herbert@gondor.apana.org.au>
> Cc: "David S. Miller" <davem@davemloft.net>
> Cc: Eric Biggers <ebiggers@kernel.org>
> Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> Cc: David Gstir <david@sigma-star.at>
> Cc: Richard Weinberger <richard@nod.at>
> Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> Cc: Sumit Garg <sumit.garg@linaro.org>
> Cc: Tim Harvey <tharvey@gateworks.com>
> Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> Cc: keyrings@vger.kernel.org
> Cc: linux-crypto@vger.kernel.org
> Cc: linux-doc@vger.kernel.org
> Cc: linux-integrity@vger.kernel.org
> Cc: linux-kernel@vger.kernel.org
> Cc: linux-security-module@vger.kernel.org
> ---
> .../admin-guide/kernel-parameters.txt | 1 +
> .../security/keys/trusted-encrypted.rst | 40 +++++++++-
> MAINTAINERS | 9 +++
> include/keys/trusted_caam.h | 11 +++
> security/keys/trusted-keys/Kconfig | 11 ++-
> security/keys/trusted-keys/Makefile | 2 +
> security/keys/trusted-keys/trusted_caam.c | 74 +++++++++++++++++++
> security/keys/trusted-keys/trusted_core.c | 6 +-
> 8 files changed, 151 insertions(+), 3 deletions(-) create mode 100644
> include/keys/trusted_caam.h create mode 100644 security/keys/trusted-
> keys/trusted_caam.c
>
> diff --git a/Documentation/admin-guide/kernel-parameters.txt
> b/Documentation/admin-guide/kernel-parameters.txt
> index 844c883ca9d8..9e7ef4c6585d 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -5875,6 +5875,7 @@
> sources:
> - "tpm"
> - "tee"
> + - "caam"
> If not specified then it defaults to iterating through
> the trust source list starting with TPM and assigns the
> first trust source as a backend which is initialized diff --git
> a/Documentation/security/keys/trusted-encrypted.rst
> b/Documentation/security/keys/trusted-encrypted.rst
> index 99cf34d7c025..ed60c48cb692 100644
> --- a/Documentation/security/keys/trusted-encrypted.rst
> +++ b/Documentation/security/keys/trusted-encrypted.rst
> @@ -35,6 +35,13 @@ safe.
> Rooted to Hardware Unique Key (HUK) which is generally burnt in on-
> chip
> fuses and is accessible to TEE only.
>
> + (3) CAAM (Cryptographic Acceleration and Assurance Module: IP on
> + NXP SoCs)
> +
> + When High Assurance Boot (HAB) is enabled and the CAAM is in secure
> + mode, trust is rooted to the OTPMK, a never-disclosed 256-bit key
> + randomly generated and fused into each SoC at manufacturing time.
> + Otherwise, a common fixed test key is used instead.
> +
> * Execution isolation
>
> (1) TPM
> @@ -46,6 +53,10 @@ safe.
> Customizable set of operations running in isolated execution
> environment verified via Secure/Trusted boot process.
>
> + (3) CAAM
> +
> + Fixed set of operations running in isolated execution environment.
> +
> * Optional binding to platform integrity state
>
> (1) TPM
> @@ -63,6 +74,11 @@ safe.
> Relies on Secure/Trusted boot process for platform integrity. It can
> be extended with TEE based measured boot process.
>
> + (3) CAAM
> +
> + Relies on the High Assurance Boot (HAB) mechanism of NXP SoCs
> + for platform integrity.
> +
> * Interfaces and APIs
>
> (1) TPM
> @@ -74,10 +90,13 @@ safe.
> TEEs have well-documented, standardized client interface and APIs. For
> more details refer to ``Documentation/staging/tee.rst``.
>
> + (3) CAAM
> +
> + Interface is specific to silicon vendor.
>
> * Threat model
>
> - The strength and appropriateness of a particular TPM or TEE for a given
> + The strength and appropriateness of a particular trust source for
> + a given
> purpose must be assessed when using them to protect security-relevant
> data.
>
>
> @@ -104,6 +123,12 @@ selected trust source:
> from platform specific hardware RNG or a software based Fortuna
> CSPRNG
> which can be seeded via multiple entropy sources.
>
> + * CAAM: Kernel RNG
> +
> + The normal kernel random number generator is used. To seed it from the
> + CAAM HWRNG, enable CRYPTO_DEV_FSL_CAAM_RNG_API and ensure
> the device
> + is probed.
> +
> Users may override this by specifying ``trusted.rng=kernel`` on the kernel
> command-line to override the used RNG with the kernel's random number
> pool.
>
> @@ -192,6 +217,19 @@ Usage::
> specific to TEE device implementation. The key length for new keys is always
> in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
>
> +Trusted Keys usage: CAAM
> +------------------------
> +
> +Usage::
> +
> + keyctl add trusted name "new keylen" ring
> + keyctl add trusted name "load hex_blob" ring
> + keyctl print keyid
> +
> +"keyctl print" returns an ASCII hex copy of the sealed key, which is in
> +format specific to CAAM device implementation. The key length for new
> +keys is always in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
> +
> Encrypted Keys usage
> --------------------
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index f670002134e0..6eca4476bb76 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -10655,6 +10655,15 @@ S: Supported
> F: include/keys/trusted_tee.h
> F: security/keys/trusted-keys/trusted_tee.c
>
> +KEYS-TRUSTED-CAAM
> +M: Ahmad Fatoum <a.fatoum@pengutronix.de>
> +R: Pengutronix Kernel Team <kernel@pengutronix.de>
> +L: linux-integrity@vger.kernel.org
> +L: keyrings@vger.kernel.org
> +S: Maintained
> +F: include/keys/trusted_caam.h
> +F: security/keys/trusted-keys/trusted_caam.c
> +
> KEYS/KEYRINGS
> M: David Howells <dhowells@redhat.com>
> M: Jarkko Sakkinen <jarkko@kernel.org>
> diff --git a/include/keys/trusted_caam.h b/include/keys/trusted_caam.h
> new file mode 100644 index 000000000000..2fba0996b0b0
> --- /dev/null
> +++ b/include/keys/trusted_caam.h
> @@ -0,0 +1,11 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
> +*/
> +
> +#ifndef __CAAM_TRUSTED_KEY_H
> +#define __CAAM_TRUSTED_KEY_H
> +
> +extern struct trusted_key_ops caam_trusted_key_ops;
> +
> +#endif
> diff --git a/security/keys/trusted-keys/Kconfig b/security/keys/trusted-
> keys/Kconfig
> index fc4abd581abb..dbfdd8536468 100644
> --- a/security/keys/trusted-keys/Kconfig
> +++ b/security/keys/trusted-keys/Kconfig
> @@ -24,6 +24,15 @@ config TRUSTED_KEYS_TEE
> Enable use of the Trusted Execution Environment (TEE) as trusted
> key backend.
>
> -if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
> +config TRUSTED_KEYS_CAAM
> + bool "CAAM-based trusted keys"
> + depends on CRYPTO_DEV_FSL_CAAM_JR >= TRUSTED_KEYS
> + select CRYPTO_DEV_FSL_CAAM_BLOB_GEN
> + default y
> + help
> + Enable use of NXP's Cryptographic Accelerator and Assurance Module
> + (CAAM) as trusted key backend.
> +
> +if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
> && !TRUSTED_KEYS_CAAM
> comment "No trust source selected!"
> endif
> diff --git a/security/keys/trusted-keys/Makefile b/security/keys/trusted-
> keys/Makefile
> index 2e2371eae4d5..735aa0bc08ef 100644
> --- a/security/keys/trusted-keys/Makefile
> +++ b/security/keys/trusted-keys/Makefile
> @@ -12,3 +12,5 @@ trusted-$(CONFIG_TRUSTED_KEYS_TPM) +=
> trusted_tpm2.o
> trusted-$(CONFIG_TRUSTED_KEYS_TPM) += tpm2key.asn1.o
>
> trusted-$(CONFIG_TRUSTED_KEYS_TEE) += trusted_tee.o
> +
> +trusted-$(CONFIG_TRUSTED_KEYS_CAAM) += trusted_caam.o
> diff --git a/security/keys/trusted-keys/trusted_caam.c
> b/security/keys/trusted-keys/trusted_caam.c
> new file mode 100644
> index 000000000000..066f08d6eb2c
> --- /dev/null
> +++ b/security/keys/trusted-keys/trusted_caam.c
> @@ -0,0 +1,74 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum <kernel@pengutronix.de>
> +*/
> +
> +#include <keys/trusted_caam.h>
> +#include <keys/trusted-type.h>
> +#include <linux/build_bug.h>
> +#include <linux/key-type.h>
> +#include <soc/fsl/caam-blob.h>
> +
> +static struct caam_blob_priv *blobifier;
> +
> +#define KEYMOD "SECURE_KEY"
> +
> +static_assert(MAX_KEY_SIZE + CAAM_BLOB_OVERHEAD <=
> CAAM_BLOB_MAX_LEN);
> +static_assert(MAX_BLOB_SIZE <= CAAM_BLOB_MAX_LEN);
> +
> +static int trusted_caam_seal(struct trusted_key_payload *p, char
> +*datablob) {
> + int length = p->key_len + CAAM_BLOB_OVERHEAD;
> + int ret;
> +
> + ret = caam_encap_blob(blobifier, KEYMOD, p->key, p->blob, length);
> + if (ret)
> + return ret;
> +
> + p->blob_len = length;
> + return 0;
> +}
> +
> +static int trusted_caam_unseal(struct trusted_key_payload *p, char
> +*datablob) {
> + int length = p->blob_len;
> + int ret;
> +
> + ret = caam_decap_blob(blobifier, KEYMOD, p->blob, p->key, length);
> + if (ret)
> + return ret;
> +
> + p->key_len = length - CAAM_BLOB_OVERHEAD;
> + return 0;
> +}
> +
> +static int trusted_caam_init(void)
> +{
> + int ret;
> +
> + blobifier = caam_blob_gen_init();
> + if (IS_ERR(blobifier)) {
> + pr_err("Job Ring Device allocation for transform failed\n");
> + return PTR_ERR(blobifier);
> + }
> +
> + ret = register_key_type(&key_type_trusted);
> + if (ret)
> + caam_blob_gen_exit(blobifier);
> +
> + return ret;
> +}
> +
> +static void trusted_caam_exit(void)
> +{
> + unregister_key_type(&key_type_trusted);
> + caam_blob_gen_exit(blobifier);
> +}
> +
> +struct trusted_key_ops caam_trusted_key_ops = {
> + .migratable = 0, /* non-migratable */
> + .init = trusted_caam_init,
> + .seal = trusted_caam_seal,
> + .unseal = trusted_caam_unseal,
> + .exit = trusted_caam_exit,
> +};
> diff --git a/security/keys/trusted-keys/trusted_core.c
> b/security/keys/trusted-keys/trusted_core.c
> index 9235fb7d0ec9..640434cd437a 100644
> --- a/security/keys/trusted-keys/trusted_core.c
> +++ b/security/keys/trusted-keys/trusted_core.c
> @@ -9,6 +9,7 @@
> #include <keys/user-type.h>
> #include <keys/trusted-type.h>
> #include <keys/trusted_tee.h>
> +#include <keys/trusted_caam.h>
> #include <keys/trusted_tpm.h>
> #include <linux/capability.h>
> #include <linux/err.h>
> @@ -29,7 +30,7 @@ MODULE_PARM_DESC(rng, "Select trusted key RNG");
>
> static char *trusted_key_source;
> module_param_named(source, trusted_key_source, charp, 0); -
> MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
> +MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee or
> +caam)");
>
> static const struct trusted_key_source trusted_key_sources[] = { #if
> defined(CONFIG_TRUSTED_KEYS_TPM) @@ -38,6 +39,9 @@ static const
> struct trusted_key_source trusted_key_sources[] = { #if
> defined(CONFIG_TRUSTED_KEYS_TEE)
> { "tee", &trusted_key_tee_ops }, #endif
> +#if defined(CONFIG_TRUSTED_KEYS_CAAM)
> + { "caam", &caam_trusted_key_ops }, #endif
> };
>
> DEFINE_STATIC_CALL_NULL(trusted_key_init,
> *trusted_key_sources[0].ops->init);
> --
> 2.30.2
^ permalink raw reply [flat|nested] 19+ messages in thread* RE: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP CAAM-based trusted keys
2022-03-02 4:37 ` Pankaj Gupta
@ 2022-03-07 4:48 ` Pankaj Gupta
0 siblings, 0 replies; 19+ messages in thread
From: Pankaj Gupta @ 2022-03-07 4:48 UTC (permalink / raw)
To: Pankaj Gupta, Ahmad Fatoum, Jonathan Corbet, David Howells,
Jarkko Sakkinen, James Bottomley, Mimi Zohar
Cc: kernel, David Gstir, tharvey, Matthias Schiffer, James Morris,
Serge E. Hallyn, Horia Geanta, Aymen Sghaier, Herbert Xu,
David S. Miller, Eric Biggers, Jan Luebbe, Richard Weinberger,
Franck Lenormand, Sumit Garg, keyrings, linux-crypto, linux-doc,
linux-integrity, linux-kernel, linux-security-module
Tested-by: Pankaj Gupta <pankaj.gupta@nxp.com>
Testing Details with iMX8 platform:
- Using command "keyctl", successfully able to create/load key from the @s keyring.
- Able to use the key with DM-Crypt utility.
- Across power cycle, Validated the decrypted content with correct key; as well as the incorrect key.
Regards
Pankaj
> -----Original Message-----
> From: Pankaj Gupta <pankaj.gupta@nxp.com>
> Sent: Wednesday, March 2, 2022 10:08 AM
> To: Ahmad Fatoum <a.fatoum@pengutronix.de>; Jonathan Corbet
> <corbet@lwn.net>; David Howells <dhowells@redhat.com>; Jarkko Sakkinen
> <jarkko@kernel.org>; James Bottomley <jejb@linux.ibm.com>; Mimi Zohar
> <zohar@linux.ibm.com>
> Cc: kernel@pengutronix.de; David Gstir <david@sigma-star.at>;
> tharvey@gateworks.com; Matthias Schiffer <matthias.schiffer@ew.tq-
> group.com>; James Morris <jmorris@namei.org>; Serge E. Hallyn
> <serge@hallyn.com>; Horia Geanta <horia.geanta@nxp.com>; Aymen
> Sghaier <aymen.sghaier@nxp.com>; Herbert Xu
> <herbert@gondor.apana.org.au>; David S. Miller <davem@davemloft.net>;
> Eric Biggers <ebiggers@kernel.org>; Jan Luebbe <j.luebbe@pengutronix.de>;
> Richard Weinberger <richard@nod.at>; Franck Lenormand
> <franck.lenormand@nxp.com>; Sumit Garg <sumit.garg@linaro.org>;
> keyrings@vger.kernel.org; linux-crypto@vger.kernel.org; linux-
> doc@vger.kernel.org; linux-integrity@vger.kernel.org; linux-
> kernel@vger.kernel.org; linux-security-module@vger.kernel.org
> Subject: RE: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP
> CAAM-based trusted keys
>
> Caution: EXT Email
>
> Reviewed-by: Pankaj Gupta <pankaj.gupta@nxp.com>
>
> > -----Original Message-----
> > From: Ahmad Fatoum <a.fatoum@pengutronix.de>
> > Sent: Wednesday, February 23, 2022 1:28 AM
> > To: Jonathan Corbet <corbet@lwn.net>; David Howells
> > <dhowells@redhat.com>; Jarkko Sakkinen <jarkko@kernel.org>; James
> > Bottomley <jejb@linux.ibm.com>; Mimi Zohar <zohar@linux.ibm.com>
> > Cc: kernel@pengutronix.de; David Gstir <david@sigma-star.at>;
> > tharvey@gateworks.com; Matthias Schiffer <matthias.schiffer@ew.tq-
> > group.com>; Ahmad Fatoum <a.fatoum@pengutronix.de>; James Morris
> > <jmorris@namei.org>; Serge E. Hallyn <serge@hallyn.com>; Horia Geanta
> > <horia.geanta@nxp.com>; Aymen Sghaier <aymen.sghaier@nxp.com>;
> Herbert
> > Xu <herbert@gondor.apana.org.au>; David S. Miller
> > <davem@davemloft.net>; Eric Biggers <ebiggers@kernel.org>; Jan Luebbe
> > <j.luebbe@pengutronix.de>; Richard Weinberger <richard@nod.at>;
> Franck
> > Lenormand <franck.lenormand@nxp.com>; Sumit Garg
> > <sumit.garg@linaro.org>; Pankaj Gupta <pankaj.gupta@nxp.com>;
> > keyrings@vger.kernel.org; linux-crypto@vger.kernel.org; linux-
> > doc@vger.kernel.org; linux-integrity@vger.kernel.org; linux-
> > kernel@vger.kernel.org; linux-security-module@vger.kernel.org
> > Subject: [EXT] [PATCH v5 5/5] KEYS: trusted: Introduce support for NXP
> > CAAM-based trusted keys
> >
> > Caution: EXT Email
> >
> > The Cryptographic Acceleration and Assurance Module (CAAM) is an IP
> > core built into many newer i.MX and QorIQ SoCs by NXP.
> >
> > The CAAM does crypto acceleration, hardware number generation and has
> > a blob mechanism for encapsulation/decapsulation of sensitive material.
> >
> > This blob mechanism depends on a device specific random 256-bit One
> > Time Programmable Master Key that is fused in each SoC at manufacturing
> time.
> > This key is unreadable and can only be used by the CAAM for AES
> > encryption/decryption of user data.
> >
> > This makes it a suitable backend (source) for kernel trusted keys.
> >
> > Previous commits generalized trusted keys to support multiple backends
> > and added an API to access the CAAM blob mechanism. Based on these,
> > provide the necessary glue to use the CAAM for trusted keys.
> >
> > Reviewed-by: David Gstir <david@sigma-star.at>
> > Tested-By: Tim Harvey <tharvey@gateworks.com>
> > Tested-by: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> > Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
> > ---
> > To: Jonathan Corbet <corbet@lwn.net>
> > To: David Howells <dhowells@redhat.com>
> > To: Jarkko Sakkinen <jarkko@kernel.org>
> > To: James Bottomley <jejb@linux.ibm.com>
> > To: Mimi Zohar <zohar@linux.ibm.com>
> > Cc: James Morris <jmorris@namei.org>
> > Cc: "Serge E. Hallyn" <serge@hallyn.com>
> > Cc: "Horia Geantă" <horia.geanta@nxp.com>
> > Cc: Aymen Sghaier <aymen.sghaier@nxp.com>
> > Cc: Herbert Xu <herbert@gondor.apana.org.au>
> > Cc: "David S. Miller" <davem@davemloft.net>
> > Cc: Eric Biggers <ebiggers@kernel.org>
> > Cc: Jan Luebbe <j.luebbe@pengutronix.de>
> > Cc: David Gstir <david@sigma-star.at>
> > Cc: Richard Weinberger <richard@nod.at>
> > Cc: Franck LENORMAND <franck.lenormand@nxp.com>
> > Cc: Sumit Garg <sumit.garg@linaro.org>
> > Cc: Tim Harvey <tharvey@gateworks.com>
> > Cc: Matthias Schiffer <matthias.schiffer@ew.tq-group.com>
> > Cc: Pankaj Gupta <pankaj.gupta@nxp.com>
> > Cc: keyrings@vger.kernel.org
> > Cc: linux-crypto@vger.kernel.org
> > Cc: linux-doc@vger.kernel.org
> > Cc: linux-integrity@vger.kernel.org
> > Cc: linux-kernel@vger.kernel.org
> > Cc: linux-security-module@vger.kernel.org
> > ---
> > .../admin-guide/kernel-parameters.txt | 1 +
> > .../security/keys/trusted-encrypted.rst | 40 +++++++++-
> > MAINTAINERS | 9 +++
> > include/keys/trusted_caam.h | 11 +++
> > security/keys/trusted-keys/Kconfig | 11 ++-
> > security/keys/trusted-keys/Makefile | 2 +
> > security/keys/trusted-keys/trusted_caam.c | 74
> +++++++++++++++++++
> > security/keys/trusted-keys/trusted_core.c | 6 +-
> > 8 files changed, 151 insertions(+), 3 deletions(-) create mode
> > 100644 include/keys/trusted_caam.h create mode 100644
> > security/keys/trusted- keys/trusted_caam.c
> >
> > diff --git a/Documentation/admin-guide/kernel-parameters.txt
> > b/Documentation/admin-guide/kernel-parameters.txt
> > index 844c883ca9d8..9e7ef4c6585d 100644
> > --- a/Documentation/admin-guide/kernel-parameters.txt
> > +++ b/Documentation/admin-guide/kernel-parameters.txt
> > @@ -5875,6 +5875,7 @@
> > sources:
> > - "tpm"
> > - "tee"
> > + - "caam"
> > If not specified then it defaults to iterating through
> > the trust source list starting with TPM and assigns the
> > first trust source as a backend which is
> > initialized diff --git
> > a/Documentation/security/keys/trusted-encrypted.rst
> > b/Documentation/security/keys/trusted-encrypted.rst
> > index 99cf34d7c025..ed60c48cb692 100644
> > --- a/Documentation/security/keys/trusted-encrypted.rst
> > +++ b/Documentation/security/keys/trusted-encrypted.rst
> > @@ -35,6 +35,13 @@ safe.
> > Rooted to Hardware Unique Key (HUK) which is generally burnt
> > in on- chip
> > fuses and is accessible to TEE only.
> >
> > + (3) CAAM (Cryptographic Acceleration and Assurance Module: IP on
> > + NXP SoCs)
> > +
> > + When High Assurance Boot (HAB) is enabled and the CAAM is in
> secure
> > + mode, trust is rooted to the OTPMK, a never-disclosed 256-bit key
> > + randomly generated and fused into each SoC at manufacturing time.
> > + Otherwise, a common fixed test key is used instead.
> > +
> > * Execution isolation
> >
> > (1) TPM
> > @@ -46,6 +53,10 @@ safe.
> > Customizable set of operations running in isolated execution
> > environment verified via Secure/Trusted boot process.
> >
> > + (3) CAAM
> > +
> > + Fixed set of operations running in isolated execution environment.
> > +
> > * Optional binding to platform integrity state
> >
> > (1) TPM
> > @@ -63,6 +74,11 @@ safe.
> > Relies on Secure/Trusted boot process for platform integrity. It can
> > be extended with TEE based measured boot process.
> >
> > + (3) CAAM
> > +
> > + Relies on the High Assurance Boot (HAB) mechanism of NXP SoCs
> > + for platform integrity.
> > +
> > * Interfaces and APIs
> >
> > (1) TPM
> > @@ -74,10 +90,13 @@ safe.
> > TEEs have well-documented, standardized client interface and APIs.
> For
> > more details refer to ``Documentation/staging/tee.rst``.
> >
> > + (3) CAAM
> > +
> > + Interface is specific to silicon vendor.
> >
> > * Threat model
> >
> > - The strength and appropriateness of a particular TPM or TEE for a given
> > + The strength and appropriateness of a particular trust source
> > + for a given
> > purpose must be assessed when using them to protect
> > security-relevant data.
> >
> >
> > @@ -104,6 +123,12 @@ selected trust source:
> > from platform specific hardware RNG or a software based Fortuna
> > CSPRNG
> > which can be seeded via multiple entropy sources.
> >
> > + * CAAM: Kernel RNG
> > +
> > + The normal kernel random number generator is used. To seed it from
> the
> > + CAAM HWRNG, enable CRYPTO_DEV_FSL_CAAM_RNG_API and
> ensure
> > the device
> > + is probed.
> > +
> > Users may override this by specifying ``trusted.rng=kernel`` on the
> > kernel command-line to override the used RNG with the kernel's random
> > number pool.
> >
> > @@ -192,6 +217,19 @@ Usage::
> > specific to TEE device implementation. The key length for new keys
> > is always in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024 bits).
> >
> > +Trusted Keys usage: CAAM
> > +------------------------
> > +
> > +Usage::
> > +
> > + keyctl add trusted name "new keylen" ring
> > + keyctl add trusted name "load hex_blob" ring
> > + keyctl print keyid
> > +
> > +"keyctl print" returns an ASCII hex copy of the sealed key, which is
> > +in format specific to CAAM device implementation. The key length for
> > +new keys is always in bytes. Trusted Keys can be 32 - 128 bytes (256 - 1024
> bits).
> > +
> > Encrypted Keys usage
> > --------------------
> >
> > diff --git a/MAINTAINERS b/MAINTAINERS index
> > f670002134e0..6eca4476bb76 100644
> > --- a/MAINTAINERS
> > +++ b/MAINTAINERS
> > @@ -10655,6 +10655,15 @@ S: Supported
> > F: include/keys/trusted_tee.h
> > F: security/keys/trusted-keys/trusted_tee.c
> >
> > +KEYS-TRUSTED-CAAM
> > +M: Ahmad Fatoum <a.fatoum@pengutronix.de>
> > +R: Pengutronix Kernel Team <kernel@pengutronix.de>
> > +L: linux-integrity@vger.kernel.org
> > +L: keyrings@vger.kernel.org
> > +S: Maintained
> > +F: include/keys/trusted_caam.h
> > +F: security/keys/trusted-keys/trusted_caam.c
> > +
> > KEYS/KEYRINGS
> > M: David Howells <dhowells@redhat.com>
> > M: Jarkko Sakkinen <jarkko@kernel.org>
> > diff --git a/include/keys/trusted_caam.h b/include/keys/trusted_caam.h
> > new file mode 100644 index 000000000000..2fba0996b0b0
> > --- /dev/null
> > +++ b/include/keys/trusted_caam.h
> > @@ -0,0 +1,11 @@
> > +/* SPDX-License-Identifier: GPL-2.0-only */
> > +/*
> > + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum
> > +<kernel@pengutronix.de> */
> > +
> > +#ifndef __CAAM_TRUSTED_KEY_H
> > +#define __CAAM_TRUSTED_KEY_H
> > +
> > +extern struct trusted_key_ops caam_trusted_key_ops;
> > +
> > +#endif
> > diff --git a/security/keys/trusted-keys/Kconfig
> > b/security/keys/trusted- keys/Kconfig index fc4abd581abb..dbfdd8536468
> > 100644
> > --- a/security/keys/trusted-keys/Kconfig
> > +++ b/security/keys/trusted-keys/Kconfig
> > @@ -24,6 +24,15 @@ config TRUSTED_KEYS_TEE
> > Enable use of the Trusted Execution Environment (TEE) as trusted
> > key backend.
> >
> > -if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
> > +config TRUSTED_KEYS_CAAM
> > + bool "CAAM-based trusted keys"
> > + depends on CRYPTO_DEV_FSL_CAAM_JR >= TRUSTED_KEYS
> > + select CRYPTO_DEV_FSL_CAAM_BLOB_GEN
> > + default y
> > + help
> > + Enable use of NXP's Cryptographic Accelerator and Assurance Module
> > + (CAAM) as trusted key backend.
> > +
> > +if !TRUSTED_KEYS_TPM && !TRUSTED_KEYS_TEE
> > && !TRUSTED_KEYS_CAAM
> > comment "No trust source selected!"
> > endif
> > diff --git a/security/keys/trusted-keys/Makefile
> > b/security/keys/trusted- keys/Makefile index
> > 2e2371eae4d5..735aa0bc08ef 100644
> > --- a/security/keys/trusted-keys/Makefile
> > +++ b/security/keys/trusted-keys/Makefile
> > @@ -12,3 +12,5 @@ trusted-$(CONFIG_TRUSTED_KEYS_TPM) +=
> trusted_tpm2.o
> > trusted-$(CONFIG_TRUSTED_KEYS_TPM) += tpm2key.asn1.o
> >
> > trusted-$(CONFIG_TRUSTED_KEYS_TEE) += trusted_tee.o
> > +
> > +trusted-$(CONFIG_TRUSTED_KEYS_CAAM) += trusted_caam.o
> > diff --git a/security/keys/trusted-keys/trusted_caam.c
> > b/security/keys/trusted-keys/trusted_caam.c
> > new file mode 100644
> > index 000000000000..066f08d6eb2c
> > --- /dev/null
> > +++ b/security/keys/trusted-keys/trusted_caam.c
> > @@ -0,0 +1,74 @@
> > +// SPDX-License-Identifier: GPL-2.0-only
> > +/*
> > + * Copyright (C) 2021 Pengutronix, Ahmad Fatoum
> > +<kernel@pengutronix.de> */
> > +
> > +#include <keys/trusted_caam.h>
> > +#include <keys/trusted-type.h>
> > +#include <linux/build_bug.h>
> > +#include <linux/key-type.h>
> > +#include <soc/fsl/caam-blob.h>
> > +
> > +static struct caam_blob_priv *blobifier;
> > +
> > +#define KEYMOD "SECURE_KEY"
> > +
> > +static_assert(MAX_KEY_SIZE + CAAM_BLOB_OVERHEAD <=
> > CAAM_BLOB_MAX_LEN);
> > +static_assert(MAX_BLOB_SIZE <= CAAM_BLOB_MAX_LEN);
> > +
> > +static int trusted_caam_seal(struct trusted_key_payload *p, char
> > +*datablob) {
> > + int length = p->key_len + CAAM_BLOB_OVERHEAD;
> > + int ret;
> > +
> > + ret = caam_encap_blob(blobifier, KEYMOD, p->key, p->blob, length);
> > + if (ret)
> > + return ret;
> > +
> > + p->blob_len = length;
> > + return 0;
> > +}
> > +
> > +static int trusted_caam_unseal(struct trusted_key_payload *p, char
> > +*datablob) {
> > + int length = p->blob_len;
> > + int ret;
> > +
> > + ret = caam_decap_blob(blobifier, KEYMOD, p->blob, p->key, length);
> > + if (ret)
> > + return ret;
> > +
> > + p->key_len = length - CAAM_BLOB_OVERHEAD;
> > + return 0;
> > +}
> > +
> > +static int trusted_caam_init(void)
> > +{
> > + int ret;
> > +
> > + blobifier = caam_blob_gen_init();
> > + if (IS_ERR(blobifier)) {
> > + pr_err("Job Ring Device allocation for transform failed\n");
> > + return PTR_ERR(blobifier);
> > + }
> > +
> > + ret = register_key_type(&key_type_trusted);
> > + if (ret)
> > + caam_blob_gen_exit(blobifier);
> > +
> > + return ret;
> > +}
> > +
> > +static void trusted_caam_exit(void)
> > +{
> > + unregister_key_type(&key_type_trusted);
> > + caam_blob_gen_exit(blobifier); }
> > +
> > +struct trusted_key_ops caam_trusted_key_ops = {
> > + .migratable = 0, /* non-migratable */
> > + .init = trusted_caam_init,
> > + .seal = trusted_caam_seal,
> > + .unseal = trusted_caam_unseal,
> > + .exit = trusted_caam_exit,
> > +};
> > diff --git a/security/keys/trusted-keys/trusted_core.c
> > b/security/keys/trusted-keys/trusted_core.c
> > index 9235fb7d0ec9..640434cd437a 100644
> > --- a/security/keys/trusted-keys/trusted_core.c
> > +++ b/security/keys/trusted-keys/trusted_core.c
> > @@ -9,6 +9,7 @@
> > #include <keys/user-type.h>
> > #include <keys/trusted-type.h>
> > #include <keys/trusted_tee.h>
> > +#include <keys/trusted_caam.h>
> > #include <keys/trusted_tpm.h>
> > #include <linux/capability.h>
> > #include <linux/err.h>
> > @@ -29,7 +30,7 @@ MODULE_PARM_DESC(rng, "Select trusted key RNG");
> >
> > static char *trusted_key_source;
> > module_param_named(source, trusted_key_source, charp, 0); -
> > MODULE_PARM_DESC(source, "Select trusted keys source (tpm or tee)");
> > +MODULE_PARM_DESC(source, "Select trusted keys source (tpm, tee or
> > +caam)");
> >
> > static const struct trusted_key_source trusted_key_sources[] = { #if
> > defined(CONFIG_TRUSTED_KEYS_TPM) @@ -38,6 +39,9 @@ static const
> struct
> > trusted_key_source trusted_key_sources[] = { #if
> > defined(CONFIG_TRUSTED_KEYS_TEE)
> > { "tee", &trusted_key_tee_ops }, #endif
> > +#if defined(CONFIG_TRUSTED_KEYS_CAAM)
> > + { "caam", &caam_trusted_key_ops }, #endif
> > };
> >
> > DEFINE_STATIC_CALL_NULL(trusted_key_init,
> > *trusted_key_sources[0].ops->init);
> > --
> > 2.30.2
^ permalink raw reply [flat|nested] 19+ messages in thread