Linux cryptographic layer development
 help / color / mirror / Atom feed
From: Rodolfo Giometti <giometti@enneenne.com>
To: David Howells <dhowells@redhat.com>,
	Jarkko Sakkinen <jarkko@kernel.org>,
	keyrings@vger.kernel.org
Cc: "Herbert Xu" <herbert@gondor.apana.org.au>,
	"David S. Miller" <davem@davemloft.net>,
	"Jens Wiklander" <jenswi@kernel.org>,
	"Sumit Garg" <sumit.garg@kernel.org>,
	op-tee@lists.trustedfirmware.org,
	"Horia Geantă" <horia.geanta@nxp.com>,
	"Pankaj Gupta" <pankaj.gupta@nxp.com>,
	"Sahil Malhotra" <sahil.malhotra@nxp.com>,
	"Ahmad Fatoum" <a.fatoum@pengutronix.de>,
	"Richard Weinberger" <richard@nod.at>,
	"Christophe Leroy (CS GROUP)" <chleroy@kernel.org>,
	"Eric Biggers" <ebiggers@kernel.org>,
	"Demi Marie Obenour" <demiobenour@gmail.com>,
	"Arnd Bergmann" <arnd@arndb.de>,
	"Paul Moore" <paul@paul-moore.com>,
	"James Morris" <jmorris@namei.org>,
	"Serge E. Hallyn" <serge@hallyn.com>,
	"Jonathan Corbet" <corbet@lwn.net>,
	"Shuah Khan" <skhan@linuxfoundation.org>,
	"Randy Dunlap" <rdunlap@infradead.org>,
	linux-crypto@vger.kernel.org, linux-integrity@vger.kernel.org,
	linux-security-module@vger.kernel.org,
	linux-kselftest@vger.kernel.org, linux-doc@vger.kernel.org,
	linux-api@vger.kernel.org, linux-arm-kernel@lists.infradead.org,
	linuxppc-dev@lists.ozlabs.org, linux-kernel@vger.kernel.org,
	"Rodolfo Giometti" <giometti@enneenne.com>
Subject: [RFC PATCH 2/9] KEYS: keycrypt: Add the sw backend
Date: Wed, 18 Nov 2026 15:04:14 +0100	[thread overview]
Message-ID: <20261118140421.584086-3-giometti@enneenne.com> (raw)
In-Reply-To: <20261118140421.584086-1-giometti@enneenne.com>

Systems with neither a TEE nor a crypto engine able to keep keys still
want keys that user space cannot read and that are bound to one
algorithm and purpose, and the same interface on every device.

Add the "sw" backend, of the kernel tier: it seals each key with
AES-256-GCM under a key derived with HMAC-SHA256 from a "trusted" key
named by master=, authenticating the keycrypt header with it, and runs
the operations with the kernel's crypto library. A loaded key is in
clear in kernel memory until revoked or destroyed, which the kernel
log says when the backend registers and when the first key is loaded;
the backend is chosen only by tier=kernel, by backend=sw, or when no
backend of a higher tier is registered, and a system that must not use
it raises the system tier above it (CONFIG_KEYCRYPT_SYSTEM_TIER_*), or
leaves this option off.

In that derivation the trusted key's material is what the HMAC
processes, under a label and a random salt as its key, and not the
other way round: AF_ALG lets user space name a trusted key by its
serial number as the key of an HMAC socket, so with the material as the
key anyone allowed to search the master could recompute the sealing
key of every blob.

It depends on TRUSTED_KEYS and is a module when trusted keys are one.

Signed-off-by: Rodolfo Giometti <giometti@enneenne.com>
---
 security/keys/keycrypt/Kconfig  |  36 ++-
 security/keys/keycrypt/Makefile |   2 +
 security/keys/keycrypt/sw.c     | 404 ++++++++++++++++++++++++++++++++
 security/keys/keycrypt/sw.h     |  30 +++
 4 files changed, 468 insertions(+), 4 deletions(-)
 create mode 100644 security/keys/keycrypt/sw.c
 create mode 100644 security/keys/keycrypt/sw.h

diff --git a/security/keys/keycrypt/Kconfig b/security/keys/keycrypt/Kconfig
index e1d1b8e2a58b..50fd4cb3b1d2 100644
--- a/security/keys/keycrypt/Kconfig
+++ b/security/keys/keycrypt/Kconfig
@@ -34,10 +34,13 @@ choice
 	help
 	  The lowest tier a keycrypt key may be used at when the kernel
 	  starts: KEYCTL_CRYPT_OPEN refuses a key of a lower tier, which
-	  can still be created and loaded. The keycrypt.system_tier= boot
-	  parameter and the kernel.keys.keycrypt_system_tier sysctl can
-	  only raise it, so a signed kernel image sets a floor its command
-	  line cannot lower.
+	  can still be created and loaded. A key of the kernel tier so
+	  created or loaded is in clear in kernel memory all the same, as
+	  its trusted master is: to have none, build without
+	  KEYCRYPT_SW, the in-tree backend of that tier. The
+	  keycrypt.system_tier= boot parameter and the
+	  kernel.keys.keycrypt_system_tier sysctl can only raise it, so a
+	  signed kernel image sets a floor its command line cannot lower.
 
 	  The default sets no floor: which backends a kernel builds says
 	  nothing about which will be present when it runs (a
@@ -70,3 +73,28 @@ config KEYCRYPT_SYSTEM_TIER_HSM
 	  keycrypt key can be used at all.
 
 endchoice
+
+config KEYCRYPT_SW
+	tristate "The sw keycrypt backend, of the kernel tier"
+	depends on KEYCRYPT && TRUSTED_KEYS
+	select CRYPTO_LIB_AES_GCM
+	select CRYPTO_LIB_AES_CBC
+	select CRYPTO_LIB_SHA256
+	help
+	  This option provides the "sw" keycrypt backend: keys sealed
+	  with AES-256-GCM under a key derived from a "trusted" key, and
+	  used by the kernel itself. While such a key is loaded, it is in
+	  clear in kernel memory: this lowers the security of the system,
+	  and the kernel says so in its log when the backend registers and
+	  when the first such key is loaded. This backend is chosen by
+	  tier=kernel or backend=sw, and for a key created with
+	  neither a tier option nor backend= whenever no backend of a
+	  higher tier is registered.
+
+	  It needs trusted keys (TRUSTED_KEYS) to seal and load keys, and
+	  is built as a module when trusted keys are one.
+
+	  Use trusted keys created with blob authorization or a policy as
+	  masters (see the documentation).
+
+	  If you are unsure as to whether this is required, answer N.
diff --git a/security/keys/keycrypt/Makefile b/security/keys/keycrypt/Makefile
index 8910fb0156e7..5a2e222a6908 100644
--- a/security/keys/keycrypt/Makefile
+++ b/security/keys/keycrypt/Makefile
@@ -1,3 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0-only
 
 obj-y += core.o ctx.o
+obj-$(CONFIG_KEYCRYPT_SW) += keycrypt_sw.o
+keycrypt_sw-y := sw.o
diff --git a/security/keys/keycrypt/sw.c b/security/keys/keycrypt/sw.c
new file mode 100644
index 000000000000..f1ff4de4afc6
--- /dev/null
+++ b/security/keys/keycrypt/sw.c
@@ -0,0 +1,404 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * keycrypt - the sw backend, of the kernel tier: keys sealed under a
+ * trusted key, used by the kernel itself
+ *
+ * The blob's layout and its GCM key are in keycrypt.rst, "The sw
+ * backend".
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <giometti@enneenne.com>
+ */
+
+#include <crypto/aes-cbc.h>
+#include <crypto/aes-gcm.h>
+#include <crypto/sha2.h>
+#include <keys/trusted-type.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/key.h>
+#include <linux/module.h>
+#include <linux/random.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include "keycrypt.h"
+#include "sw.h"
+
+/* <keys/trusted-type.h> redefines pr_fmt; reassert ours after it */
+#undef pr_fmt
+#define pr_fmt(fmt) "keycrypt: " fmt
+
+#define SW_LABEL	"keycrypt kernel-tier v1"
+#define SW_AAD_MAX	(KEYCRYPT_HEADER_MAX + 2 + KEYCRYPT_SW_DESC_MAX + \
+			 KEYCRYPT_SW_SALT_LEN)
+
+static int sw_prepare(struct aes_gcm_key *gk, const u8 *master, size_t mlen,
+		      const u8 *salt)
+{
+	u8 label[sizeof(SW_LABEL) - 1 + KEYCRYPT_SW_SALT_LEN];
+	u8 dk[SHA256_DIGEST_SIZE];
+	int ret;
+
+	memcpy(label, SW_LABEL, sizeof(SW_LABEL) - 1);
+	memcpy(label + sizeof(SW_LABEL) - 1, salt, KEYCRYPT_SW_SALT_LEN);
+	/*
+	 * The master is the data, never the key: AF_ALG keys an HMAC with
+	 * a trusted key given by serial, so whoever may search the master
+	 * could otherwise compute this key.
+	 */
+	hmac_sha256_usingrawkey(label, sizeof(label), master, mlen, dk);
+	ret = aes_gcm_preparekey(gk, dk, sizeof(dk), KEYCRYPT_SW_TAG_LEN);
+	memzero_explicit(dk, sizeof(dk));
+	return ret;
+}
+
+static size_t sw_aad(u8 *aad, const u8 *hdr, u32 hdr_len, const u8 *prefix,
+		     size_t prefix_len)
+{
+	memcpy(aad, hdr, hdr_len);
+	memcpy(aad + hdr_len, prefix, prefix_len);
+	return hdr_len + prefix_len;
+}
+
+static int keycrypt_sw_seal(const u8 *master, size_t mlen,
+			    const u8 *hdr, u32 hdr_len,
+			    const char *desc, const u8 *key,
+			    size_t klen, struct keycrypt_blob *out)
+{
+	size_t dlen = strlen(desc), prefix_len, alen, len;
+	struct aes_gcm_key gk;
+	u8 aad[SW_AAD_MAX];
+	u8 *p, *salt, *nonce, *ct;
+	int ret;
+
+	if (!dlen || dlen > KEYCRYPT_SW_DESC_MAX ||
+	    hdr_len > KEYCRYPT_HEADER_MAX || !klen ||
+	    klen > KEYCRYPT_SW_KEY_MAX)
+		return -EINVAL;
+	len = 2 + dlen + KEYCRYPT_SW_SALT_LEN + KEYCRYPT_SW_NONCE_LEN + klen +
+	      KEYCRYPT_SW_TAG_LEN;
+	p = kmalloc(len, GFP_KERNEL);
+	if (!p)
+		return -ENOMEM;
+	p[0] = KEYCRYPT_SW_VERSION;
+	p[1] = dlen;
+	memcpy(p + 2, desc, dlen);
+	salt = p + 2 + dlen;
+	nonce = salt + KEYCRYPT_SW_SALT_LEN;
+	ct = nonce + KEYCRYPT_SW_NONCE_LEN;
+	ret = get_random_bytes_wait(salt, KEYCRYPT_SW_SALT_LEN);
+	if (ret) {
+		kfree(p);
+		return ret;
+	}
+	ret = sw_prepare(&gk, master, mlen, salt);
+	if (ret) {
+		kfree(p);
+		return ret;
+	}
+	ret = get_random_bytes_wait(nonce, KEYCRYPT_SW_NONCE_LEN);
+	if (ret) {
+		memzero_explicit(&gk, sizeof(gk));
+		kfree(p);
+		return ret;
+	}
+	prefix_len = 2 + dlen + KEYCRYPT_SW_SALT_LEN;
+	alen = sw_aad(aad, hdr, hdr_len, p, prefix_len);
+	aes_gcm_encrypt(ct, key, klen, ct + klen, aad, alen, nonce, &gk);
+	memzero_explicit(&gk, sizeof(gk));
+	out->data = p;
+	out->len = len;
+	return 0;
+}
+
+static int keycrypt_sw_unseal(const u8 *master, size_t mlen,
+			      const u8 *hdr, u32 hdr_len,
+			      const u8 *data, u32 len, u8 *key,
+			      size_t *klen)
+{
+	const u8 *salt, *nonce, *ct;
+	struct aes_gcm_key gk;
+	size_t dlen, clen, alen, prefix_len;
+	u8 aad[SW_AAD_MAX];
+	int ret;
+
+	if (len < 2 || data[0] != KEYCRYPT_SW_VERSION ||
+	    hdr_len > KEYCRYPT_HEADER_MAX)
+		return -EBADMSG;
+	dlen = data[1];
+	if (!dlen ||
+	    len < 2 + dlen + KEYCRYPT_SW_SALT_LEN + KEYCRYPT_SW_NONCE_LEN + 1 +
+		  KEYCRYPT_SW_TAG_LEN)
+		return -EBADMSG;
+	clen = len - 2 - dlen - KEYCRYPT_SW_SALT_LEN - KEYCRYPT_SW_NONCE_LEN -
+	       KEYCRYPT_SW_TAG_LEN;
+	if (clen > KEYCRYPT_SW_KEY_MAX)
+		return -EBADMSG;
+	salt = data + 2 + dlen;
+	nonce = salt + KEYCRYPT_SW_SALT_LEN;
+	ct = nonce + KEYCRYPT_SW_NONCE_LEN;
+	prefix_len = 2 + dlen + KEYCRYPT_SW_SALT_LEN;
+	alen = sw_aad(aad, hdr, hdr_len, data, prefix_len);
+	ret = sw_prepare(&gk, master, mlen, salt);
+	if (ret)
+		return ret;
+	ret = aes_gcm_decrypt(key, ct, clen, ct + clen, aad, alen, nonce, &gk);
+	memzero_explicit(&gk, sizeof(gk));
+	if (ret) {
+		memzero_explicit(key, clen);
+		return -EBADMSG;
+	}
+	*klen = clen;
+	return 0;
+}
+
+/*
+ * Copy the key material of the trusted key @desc that the caller can
+ * search for into @buf (MAX_KEY_SIZE bytes). No callout information, so no
+ * upcall: the key must exist, though it may still be under construction,
+ * and then this waits for it with the backend's handle held: the one wait
+ * without bound in this backend's callbacks. Not request_key_rcu(): it
+ * misses keys that the RCU walk cannot reach, such as those of the user
+ * keyring of a process without a session keyring.
+ */
+static int sw_master(const char *desc, u8 *buf, size_t *len)
+{
+	const struct trusted_key_payload *tp;
+	struct key *mk;
+	int ret;
+
+	mk = request_key(&key_type_trusted, desc, NULL);
+	if (IS_ERR(mk))
+		return PTR_ERR(mk) == -EACCES ? -EACCES : -ENOKEY;
+	down_read(&mk->sem);
+	tp = dereference_key_locked(mk);
+	if (key_validate(mk) || !tp || tp->key_len < MIN_KEY_SIZE ||
+	    tp->key_len > MAX_KEY_SIZE) {
+		ret = -ENOKEY;
+	} else {
+		memcpy(buf, tp->key, tp->key_len);
+		*len = tp->key_len;
+		ret = 0;
+	}
+	up_read(&mk->sem);
+	key_put(mk);
+	return ret;
+}
+
+/* The one option of the sw backend: "master=<description>" */
+static int sw_master_opt(const char *opts, const char **desc)
+{
+	if (!opts || strncmp(opts, "master=", 7) || !opts[7])
+		return -EINVAL;
+	*desc = opts + 7;
+	return 0;
+}
+
+static int sw_seal_key(const u8 *hdr, u32 hdr_len, const char *opts,
+		       const u8 *key, size_t klen, struct keycrypt_blob *out)
+{
+	u8 master[MAX_KEY_SIZE];
+	const char *desc;
+	size_t mlen;
+	int ret;
+
+	ret = sw_master_opt(opts, &desc);
+	if (ret)
+		return ret;
+	if (strlen(desc) > KEYCRYPT_SW_DESC_MAX)
+		return -EINVAL;
+	ret = sw_master(desc, master, &mlen);
+	if (!ret)
+		ret = keycrypt_sw_seal(master, mlen, hdr, hdr_len, desc, key,
+				       klen, out);
+	memzero_explicit(master, sizeof(master));
+	return ret;
+}
+
+static int sw_generate(struct keycrypt_backend *b,
+		       const struct keycrypt_meta *m, const u8 *hdr,
+		       u32 hdr_len, const char *opts,
+		       struct keycrypt_blob *out)
+{
+	u8 key[32];
+	int ret;
+
+	ret = get_random_bytes_wait(key, sizeof(key));
+	if (!ret)
+		ret = sw_seal_key(hdr, hdr_len, opts, key, sizeof(key), out);
+	memzero_explicit(key, sizeof(key));
+	return ret;
+}
+
+static int sw_import(struct keycrypt_backend *b,
+		     const struct keycrypt_meta *m, const u8 *hdr,
+		     u32 hdr_len, const char *opts, const u8 *key,
+		     size_t keylen, struct keycrypt_blob *out)
+{
+	return sw_seal_key(hdr, hdr_len, opts, key, keylen, out);
+}
+
+static int sw_load(struct keycrypt_backend *b, struct keycrypt_key *k,
+		   const char *opts)
+{
+	char desc[KEYCRYPT_SW_DESC_MAX + 1];
+	u8 master[MAX_KEY_SIZE];
+	struct keycrypt_sw_key *priv;
+	size_t mlen, dlen;
+	int ret;
+
+	if (opts)
+		return -EINVAL;
+	if (k->data_len < 2 || !k->data[1])
+		return -EBADMSG;
+	dlen = k->data[1];
+	if (k->data_len < 2 + dlen)
+		return -EBADMSG;
+	memcpy(desc, k->data + 2, dlen);
+	desc[dlen] = '\0';
+	if (strlen(desc) != dlen)
+		return -EBADMSG;
+
+	priv = kzalloc_obj(*priv);
+	if (!priv)
+		return -ENOMEM;
+	ret = sw_master(desc, master, &mlen);
+	if (!ret)
+		ret = keycrypt_sw_unseal(master, mlen, k->hdr, k->hdr_len,
+					 k->data, k->data_len, priv->key,
+					 &priv->len);
+	memzero_explicit(master, sizeof(master));
+	if (!ret && !keycrypt_key_len_valid(k->meta.alg, priv->len))
+		ret = -EBADMSG;
+	if (ret) {
+		kfree_sensitive(priv);
+		return ret;
+	}
+	k->priv = priv;
+	pr_warn_once("a key of the kernel tier is loaded: it is in clear in kernel memory\n");
+	return 0;
+}
+
+static void sw_destroy(struct keycrypt_backend *b, struct keycrypt_key *k)
+{
+	kfree_sensitive(k->priv);
+	k->priv = NULL;
+}
+
+struct sw_ctx {
+	u32 op;
+	union {
+		struct {
+			union {
+				struct aes_key    key;	    /* decrypt */
+				struct aes_enckey enc_key; /* encrypt-only */
+			};
+			u8 iv[AES_BLOCK_SIZE];
+		} cbc;
+		struct hmac_sha256_ctx mac;
+	};
+};
+
+static int sw_ctx_open(struct keycrypt_backend *b, struct keycrypt_key *k,
+		       u32 op, u8 *iv, void **ctx)
+{
+	struct keycrypt_sw_key *kk = k->priv;
+	struct sw_ctx *c;
+	int ret;
+
+	if (!kk)
+		return -EIO;
+	c = kzalloc_obj(*c, GFP_KERNEL_ACCOUNT);
+	if (!c)
+		return -ENOMEM;
+	c->op = op;
+	if (op == KEYCRYPT_OP_MAC || op == KEYCRYPT_OP_VERIFY) {
+		hmac_sha256_init_usingrawkey(&c->mac, kk->key, kk->len);
+	} else {
+		ret = op == KEYCRYPT_OP_ENCRYPT ?
+		      aes_prepareenckey(&c->cbc.enc_key, kk->key, kk->len) :
+		      aes_preparekey(&c->cbc.key, kk->key, kk->len);
+		if (ret) {
+			kfree_sensitive(c);
+			return -EIO;
+		}
+		memcpy(c->cbc.iv, iv, AES_BLOCK_SIZE);
+	}
+	*ctx = c;
+	return 0;
+}
+
+static int sw_update(struct keycrypt_backend *b, void *ctx, const u8 *in,
+		     u8 *out, size_t len)
+{
+	struct sw_ctx *c = ctx;
+
+	switch (c->op) {
+	case KEYCRYPT_OP_ENCRYPT:
+		aes_cbc_encrypt(out, in, len, c->cbc.iv, &c->cbc.enc_key);
+		break;
+	case KEYCRYPT_OP_DECRYPT:
+		aes_cbc_decrypt(out, in, len, c->cbc.iv, &c->cbc.key);
+		break;
+	default:
+		hmac_sha256_update(&c->mac, in, len);
+	}
+	return 0;
+}
+
+static int sw_final(struct keycrypt_backend *b, void *ctx, u8 *out,
+		    size_t out_size, size_t *len)
+{
+	struct sw_ctx *c = ctx;
+
+	if (c->op == KEYCRYPT_OP_MAC || c->op == KEYCRYPT_OP_VERIFY) {
+		if (out_size < SHA256_DIGEST_SIZE)
+			return -EIO;
+		hmac_sha256_final(&c->mac, out);
+		*len = SHA256_DIGEST_SIZE;
+	} else {
+		*len = 0;
+	}
+	return 0;
+}
+
+static void sw_ctx_free(struct keycrypt_backend *b, void *ctx)
+{
+	kfree_sensitive(ctx);
+}
+
+static const char * const sw_opts[] = { "master", NULL };
+
+static struct keycrypt_backend keycrypt_sw = {
+	.name		= "sw",
+	.tier		= KEYCRYPT_TIER_KERNEL,
+	.algs		= KEYCRYPT_ALGS_ALL,
+	.owner		= THIS_MODULE,
+	.opts		= sw_opts,
+	.generate	= sw_generate,
+	.import		= sw_import,
+	.load		= sw_load,
+	.destroy	= sw_destroy,
+	.ctx_open	= sw_ctx_open,
+	.update		= sw_update,
+	.final		= sw_final,
+	.ctx_free	= sw_ctx_free,
+};
+
+static int __init keycrypt_sw_init(void)
+{
+	int ret = keycrypt_register_backend(&keycrypt_sw);
+
+	if (!ret)
+		pr_warn("kernel tier enabled: its keys are in clear in kernel memory while loaded\n");
+	return ret;
+}
+module_init(keycrypt_sw_init);
+
+static void __exit keycrypt_sw_exit(void)
+{
+	keycrypt_unregister_backend(&keycrypt_sw);
+}
+module_exit(keycrypt_sw_exit);
+
+MODULE_DESCRIPTION("keycrypt sw backend, of the kernel tier");
+MODULE_LICENSE("GPL");
diff --git a/security/keys/keycrypt/sw.h b/security/keys/keycrypt/sw.h
new file mode 100644
index 000000000000..30e24fb56ce3
--- /dev/null
+++ b/security/keys/keycrypt/sw.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * keycrypt - the sw backend's blob fields and loaded-key state
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <giometti@enneenne.com>
+ */
+
+#ifndef _SECURITY_KEYS_KEYCRYPT_SW_H
+#define _SECURITY_KEYS_KEYCRYPT_SW_H
+
+#include <linux/types.h>
+
+#define KEYCRYPT_SW_VERSION	1
+#define KEYCRYPT_SW_SALT_LEN	32
+#define KEYCRYPT_SW_NONCE_LEN	12
+#define KEYCRYPT_SW_TAG_LEN	16
+#define KEYCRYPT_SW_DESC_MAX	255
+#define KEYCRYPT_SW_KEY_MAX	64
+
+/**
+ * struct keycrypt_sw_key - the sw backend's state for a loaded key
+ * @len: bytes in @key
+ * @key: the key, in clear
+ */
+struct keycrypt_sw_key {
+	size_t	len;
+	u8	key[KEYCRYPT_SW_KEY_MAX];
+};
+
+#endif /* _SECURITY_KEYS_KEYCRYPT_SW_H */
-- 
2.43.0


  parent reply	other threads:[~2026-11-18 14:05 UTC|newest]

Thread overview: 8+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18 14:04 [RFC PATCH 0/9] KEYS: keycrypt: keys that user space can use but never read Rodolfo Giometti
2026-11-18 14:04 ` [RFC PATCH 1/9] KEYS: keycrypt: Add a key type for keys user space never reads Rodolfo Giometti
2026-11-18 14:04 ` Rodolfo Giometti [this message]
2026-11-18 14:04 ` [RFC PATCH 3/9] KEYS: keycrypt: Add the OP-TEE backend Rodolfo Giometti
2026-11-18 14:07 ` [RFC PATCH 4/9] docs: keycrypt: document keycrypt keys Rodolfo Giometti
2026-11-18 14:08 ` [RFC PATCH 5/9] MAINTAINERS: add KEYS-KEYCRYPT Rodolfo Giometti
2026-11-18 14:09 ` [RFC PATCH 6/9] KEYS: keycrypt: Add the engine tier Rodolfo Giometti
2026-11-18 14:10 ` [RFC PATCH 7/9] crypto: caam - add an internal cbc(paes) taking the blob's key modifier Rodolfo Giometti

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118140421.584086-3-giometti@enneenne.com \
    --to=giometti@enneenne.com \
    --cc=a.fatoum@pengutronix.de \
    --cc=arnd@arndb.de \
    --cc=chleroy@kernel.org \
    --cc=corbet@lwn.net \
    --cc=davem@davemloft.net \
    --cc=demiobenour@gmail.com \
    --cc=dhowells@redhat.com \
    --cc=ebiggers@kernel.org \
    --cc=herbert@gondor.apana.org.au \
    --cc=horia.geanta@nxp.com \
    --cc=jarkko@kernel.org \
    --cc=jenswi@kernel.org \
    --cc=jmorris@namei.org \
    --cc=keyrings@vger.kernel.org \
    --cc=linux-api@vger.kernel.org \
    --cc=linux-arm-kernel@lists.infradead.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-kselftest@vger.kernel.org \
    --cc=linux-security-module@vger.kernel.org \
    --cc=linuxppc-dev@lists.ozlabs.org \
    --cc=op-tee@lists.trustedfirmware.org \
    --cc=pankaj.gupta@nxp.com \
    --cc=paul@paul-moore.com \
    --cc=rdunlap@infradead.org \
    --cc=richard@nod.at \
    --cc=sahil.malhotra@nxp.com \
    --cc=serge@hallyn.com \
    --cc=skhan@linuxfoundation.org \
    --cc=sumit.garg@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox