Programs that encrypt, decrypt or authenticate data with a symmetric
key today hold that key: in a file, in a "user" or "logon" key handed
to AF_ALG, or in memory a compromised process can read. On a device
with a TEE or a crypto engine able to keep keys, nothing lets an
ordinary program use such a key through a kernel interface, with the
key fixed to one algorithm and purpose and never released.

Add the "keycrypt" key type. A key is created by a backend ("new"),
sealed from a key given in clear by CAP_SYS_ADMIN ("import", behind
CONFIG_KEYCRYPT_IMPORT), or re-created from the blob its backend
sealed ("load"); its algorithm (aes256-cbc, hmac-sha256), purpose and
protection tier (kernel, tee, hsm) are fixed at creation and
authenticated in the blob. User space reads only the blob.

This adds a user API: KEYCTL_CRYPT_OPEN opens an operation context on
a key, a file descriptor whose ioctls run the operation in the key's
backend, as the documentation describes. Two system policies come as
sysctls and boot parameters, both one-way: the system tier, a floor on
the use of keys whose starting value is chosen at build time
(CONFIG_KEYCRYPT_SYSTEM_TIER_*), and an import switch.

Backends register through keycrypt_register_backend(); none is added
here, so a well-formed add_key() fails with ENODEV until one is.

Signed-off-by: Rodolfo Giometti <[email protected]>
---
 .../admin-guide/kernel-parameters.txt         |   20 +
 .../userspace-api/ioctl/ioctl-number.rst      |    2 +
 include/keys/keycrypt.h                       |  150 +++
 include/uapi/linux/keycrypt.h                 |  143 +++
 include/uapi/linux/keyctl.h                   |    1 +
 security/keys/Kconfig                         |    2 +
 security/keys/Makefile                        |    1 +
 security/keys/compat.c                        |    3 +
 security/keys/internal.h                      |   12 +
 security/keys/keycrypt/Kconfig                |   72 ++
 security/keys/keycrypt/Makefile               |    3 +
 security/keys/keycrypt/core.c                 | 1070 +++++++++++++++++
 security/keys/keycrypt/ctx.c                  |  530 ++++++++
 security/keys/keycrypt/keycrypt.h             |  173 +++
 security/keys/keyctl.c                        |    5 +
 15 files changed, 2187 insertions(+)
 create mode 100644 include/keys/keycrypt.h
 create mode 100644 include/uapi/linux/keycrypt.h
 create mode 100644 security/keys/keycrypt/Kconfig
 create mode 100644 security/keys/keycrypt/Makefile
 create mode 100644 security/keys/keycrypt/core.c
 create mode 100644 security/keys/keycrypt/ctx.c
 create mode 100644 security/keys/keycrypt/keycrypt.h

diff --git a/Documentation/admin-guide/kernel-parameters.txt 
b/Documentation/admin-guide/kernel-parameters.txt
index 0b3c140babd9..62d44a5225e4 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -2935,6 +2935,26 @@ Kernel parameters
                        for Movable pages.  "nn[KMGTPE]", "nn%", and "mirror"
                        are exclusive, so you cannot specify multiple forms.
 
+       keycrypt.import=        [KEYS] Allow importing clear key material into
+                       keycrypt keys (CONFIG_KEYCRYPT_IMPORT).
+                       Format: <bool>
+                       Default: 1. 0 disables import until reboot; an
+                       invalid value, or turning it back on, is
+                       ignored, with a kernel warning. The
+                       kernel.keys.keycrypt_import sysctl can later
+                       turn it off the same way, but never back on.
+
+       keycrypt.system_tier=   [KEYS] Lowest protection tier a keycrypt key
+                       may be used at; keys of a lower tier can still
+                       be created and loaded.
+                       Format: { kernel | tee | hsm }
+                       Default: the CONFIG_KEYCRYPT_SYSTEM_TIER_*
+                       choice, kernel unless set. Can only be raised,
+                       here or later through the
+                       kernel.keys.keycrypt_system_tier sysctl; an
+                       invalid name, or a tier lower than already set,
+                       is ignored, with a kernel warning.
+
        kfence.burst=   [MM,KFENCE] The number of additional successive
                        allocations to be attempted through KFENCE for each
                        sample interval.
diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst 
b/Documentation/userspace-api/ioctl/ioctl-number.rst
index dbe462040999..efdace54085b 100644
--- a/Documentation/userspace-api/ioctl/ioctl-number.rst
+++ b/Documentation/userspace-api/ioctl/ioctl-number.rst
@@ -387,6 +387,8 @@ Code  Seq#    Include File                                  
           Comments
                                                                        
<mailto:[email protected]>
 0xBA  00-0F  uapi/linux/liveupdate.h                                   Pasha 
Tatashin
                                                                        
<mailto:[email protected]>
+0xBB  00-0F  uapi/linux/keycrypt.h                                     keycrypt
+                                                                       
<mailto:[email protected]>
 0xC0  00-0F  linux/usb/iowarrior.h
 0xCA  00-0F  uapi/misc/cxl.h                                           Dead 
since 6.15
 0xCA  10-2F  uapi/misc/ocxl.h
diff --git a/include/keys/keycrypt.h b/include/keys/keycrypt.h
new file mode 100644
index 000000000000..8aae3d47e697
--- /dev/null
+++ b/include/keys/keycrypt.h
@@ -0,0 +1,150 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * keycrypt - the interface for the backends that hold and use the keys
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <[email protected]>
+ */
+
+#ifndef _KEYS_KEYCRYPT_H
+#define _KEYS_KEYCRYPT_H
+
+#include <linux/bits.h>
+#include <linux/types.h>
+#include <uapi/linux/keycrypt.h>
+
+struct module;
+struct keycrypt_handle;
+
+#define KEYCRYPT_ALGS_ALL              (BIT(KEYCRYPT_ALG_AES256_CBC) | \
+                                        BIT(KEYCRYPT_ALG_HMAC_SHA256))
+
+#define KEYCRYPT_BACKEND_DATA_MAX      4096
+
+/*
+ * Header of a blob: "KCR", version, flags, algorithm, purpose (le16),
+ * tier, origin, name length, then the name
+ */
+#define KEYCRYPT_HEADER_FIXED          11
+#define KEYCRYPT_HEADER_MAX            (KEYCRYPT_HEADER_FIXED + \
+                                        KEYCRYPT_BACKEND_NAME_MAX)
+
+/**
+ * struct keycrypt_meta - metadata fixed when a key is created
+ * @alg: KEYCRYPT_ALG_*
+ * @purpose: KEYCRYPT_PURPOSE_* mask
+ * @tier: KEYCRYPT_TIER_* the key was sealed at
+ * @origin: KEYCRYPT_ORIGIN_*
+ * @backend: name of the backend, NUL terminated
+ */
+struct keycrypt_meta {
+       u8      alg;
+       u16     purpose;
+       u8      tier;
+       u8      origin;
+       char    backend[KEYCRYPT_BACKEND_NAME_MAX + 1];
+};
+
+/**
+ * struct keycrypt_blob - data a backend creates for a new key
+ * @data: allocated with kmalloc() by the backend, freed by the core on
+ *     every path, success or not
+ * @len: 1 to KEYCRYPT_BACKEND_DATA_MAX bytes
+ */
+struct keycrypt_blob {
+       u8      *data;
+       u32     len;
+};
+
+/**
+ * struct keycrypt_key - a key as its backend sees it
+ * @meta: its metadata
+ * @hdr: the header stored in the blob; the backend's data must
+ *     authenticate exactly these bytes
+ * @hdr_len: bytes in @hdr
+ * @data: the backend's data, as stored
+ * @data_len: bytes in @data
+ * @priv: the backend's state for this key, set by @load and released by
+ *     @destroy
+ */
+struct keycrypt_key {
+       struct keycrypt_meta    meta;
+       const u8                *hdr;
+       u32                     hdr_len;
+       const u8                *data;
+       u32                     data_len;
+       void                    *priv;
+};
+
+/**
+ * struct keycrypt_backend - a place where keycrypt keys live
+ * @name: [a-z0-9_-], at most KEYCRYPT_BACKEND_NAME_MAX; it names a sealing
+ *     domain and is stored in every blob
+ * @tier: KEYCRYPT_TIER_*; _TEE and _HSM declare that the backend meets
+ *     Documentation/security/keys/keycrypt.rst, "Backend requirements"
+ * @algs: BIT(KEYCRYPT_ALG_*) mask of what it supports
+ * @owner: module holding the callbacks, pinned by every key
+ * @opts: NULL-terminated list of the option keys it accepts ("master"
+ *     for "master=<value>"); the core refuses any other, and duplicates
+ * @generate: create a key; its data must authenticate @hdr
+ * @import: seal a key given in clear, likewise; NULL if not supported
+ * @load: check that @k's data authenticates @k->hdr (-EBADMSG if not) and
+ *     set @k->priv if needed, leaving it unset on failure
+ * @destroy: release @k->priv; called at most once per key, and last
+ * @ctx_open: start @op on @k and set *@ctx, releasing what it acquired on
+ *     failure; @iv (16 bytes) is the aes256-cbc IV, used as given
+ * @update: process @len bytes from @in to @out, in place allowed; @out is
+ *     NULL for MAC and VERIFY
+ * @final: end the context; MAC and VERIFY write the 32-byte tag to @out
+ *     and set *@len, the ciphers set it to 0
+ * @verify: end a VERIFY context by comparing the tag with @expected where
+ *     the key lives, 0 or -EBADMSG, never the tag. Required of a _TEE or
+ *     _HSM backend with context callbacks offering hmac-sha256
+ * @ctx_free: release @ctx, once, however the context ends
+ * @handle: core private
+ *
+ * @opts given to a callback are the "key=value" options the core did not
+ * consume, or NULL. Errors of @generate, @import and @load reach user
+ * space as given for -ENOMEM, -EINVAL, -EBADMSG, -ENOKEY, -EKEYREJECTED,
+ * -EACCES, -EINTR and -ERESTARTSYS, those of the context callbacks only
+ * for -ENOMEM, -EINTR, -ERESTARTSYS and -EBADMSG; any other is -EIO.
+ *
+ * The callbacks may sleep and run concurrently, with the backend's handle
+ * held: they must not call into keycrypt, and must not wait without bound.
+ * The four context callbacks are all given or all NULL; without them the
+ * backend's keys cannot be used (KEYCTL_CRYPT_OPEN gives -ENODEV).
+ */
+struct keycrypt_backend {
+       const char      *name;
+       u8              tier;
+       u32             algs;
+       struct module   *owner;
+       const char * const *opts;
+
+       int (*generate)(struct keycrypt_backend *b,
+                       const struct keycrypt_meta *m, const u8 *hdr,
+                       u32 hdr_len, const char *opts,
+                       struct keycrypt_blob *out);
+       int (*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);
+       int (*load)(struct keycrypt_backend *b, struct keycrypt_key *k,
+                   const char *opts);
+       void (*destroy)(struct keycrypt_backend *b, struct keycrypt_key *k);
+       int (*ctx_open)(struct keycrypt_backend *b, struct keycrypt_key *k,
+                       u32 op, u8 *iv, void **ctx);
+       int (*update)(struct keycrypt_backend *b, void *ctx, const u8 *in,
+                     u8 *out, size_t len);
+       int (*final)(struct keycrypt_backend *b, void *ctx, u8 *out,
+                    size_t out_size, size_t *len);
+       int (*verify)(struct keycrypt_backend *b, void *ctx,
+                     const u8 *expected);
+       void (*ctx_free)(struct keycrypt_backend *b, void *ctx);
+
+       struct keycrypt_handle *handle;
+};
+
+int keycrypt_register_backend(struct keycrypt_backend *b);
+void keycrypt_unregister_backend(struct keycrypt_backend *b);
+
+#endif /* _KEYS_KEYCRYPT_H */
diff --git a/include/uapi/linux/keycrypt.h b/include/uapi/linux/keycrypt.h
new file mode 100644
index 000000000000..c03348579f62
--- /dev/null
+++ b/include/uapi/linux/keycrypt.h
@@ -0,0 +1,143 @@
+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */
+/*
+ * keycrypt - the user-space API
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <[email protected]>
+ */
+
+#ifndef _UAPI_LINUX_KEYCRYPT_H
+#define _UAPI_LINUX_KEYCRYPT_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/* Protection tiers, lowest first; the gaps leave room for more */
+#define KEYCRYPT_TIER_KERNEL   10      /* the kernel itself */
+#define KEYCRYPT_TIER_TEE      20      /* a trusted execution environment */
+/* as TEE, in dedicated hardware apart from the CPU running the kernel */
+#define KEYCRYPT_TIER_HSM      30
+
+/*
+ * Operations of KEYCTL_CRYPT_OPEN; which ones a key allows depends on its
+ * algorithm and purposes, see Documentation/security/keys/keycrypt.rst
+ */
+#define KEYCRYPT_OP_ENCRYPT    1
+#define KEYCRYPT_OP_DECRYPT    2
+#define KEYCRYPT_OP_MAC                3
+#define KEYCRYPT_OP_VERIFY     4
+
+/*
+ * KEYCTL_CRYPT_OPEN flags. KEYCRYPT_OPEN_CALLER_IV: encrypt with an IV
+ * the caller gives instead of one the kernel draws, for data formats
+ * that fix or derive the IV themselves; the caller then answers for
+ * its unpredictability. Without it, the kernel draws the IV.
+ */
+#define KEYCRYPT_OPEN_CALLER_IV        0x0001
+
+/* struct keycrypt_info: the key's algorithm */
+#define KEYCRYPT_ALG_AES256_CBC                1
+#define KEYCRYPT_ALG_HMAC_SHA256       2
+
+/* struct keycrypt_info: the key's purpose mask */
+#define KEYCRYPT_PURPOSE_ENCRYPT       0x0001
+#define KEYCRYPT_PURPOSE_DECRYPT       0x0002
+#define KEYCRYPT_PURPOSE_MAC           0x0004
+#define KEYCRYPT_PURPOSE_VERIFY                0x0008
+
+/* struct keycrypt_info: the key's origin */
+#define KEYCRYPT_ORIGIN_GENERATED      1
+#define KEYCRYPT_ORIGIN_IMPORTED       2
+
+/*
+ * A backend's name: at most this many characters, then a NUL (struct
+ * keycrypt_info's @backend has room for more)
+ */
+#define KEYCRYPT_BACKEND_NAME_MAX      16
+
+/**
+ * struct keycrypt_open_params - KEYCTL_CRYPT_OPEN parameters
+ * @op: KEYCRYPT_OP_*
+ * @accepted_min_tier: KEYCRYPT_TIER_*: refuse a key of a lower tier; 0:
+ *     no requirement beyond the system tier
+ * @flags: KEYCRYPT_OPEN_*
+ * @__reserved: must be zero
+ * @iv: aes256-cbc: the IV, given for decryption and with
+ *     KEYCRYPT_OPEN_CALLER_IV, otherwise written back by the kernel; MAC
+ *     and VERIFY: zero
+ *
+ * Extended by size (copy_struct_from_user()); at least
+ * KEYCRYPT_OPEN_PARAMS_SIZE_VER0 bytes.
+ */
+struct keycrypt_open_params {
+       __u32   op;
+       __u32   accepted_min_tier;
+       __u32   flags;
+       __u32   __reserved;
+       __u8    iv[16];
+};
+
+#define KEYCRYPT_OPEN_PARAMS_SIZE_VER0 32
+
+/**
+ * struct keycrypt_update - KEYCRYPT_IOC_UPDATE argument
+ * @in: user pointer to @len input bytes
+ * @out: user pointer to @len output bytes; 0 for MAC and VERIFY
+ * @len: bytes, at most KEYCRYPT_UPDATE_MAX; aes256-cbc: a multiple of 16
+ * @flags: must be zero
+ */
+struct keycrypt_update {
+       __u64   in;
+       __u64   out;
+       __u32   len;
+       __u32   flags;
+};
+
+/**
+ * struct keycrypt_final - KEYCRYPT_IOC_FINAL argument
+ * @out: user pointer; MAC: the tag, written, @len room in, bytes out;
+ *     VERIFY: the expected 32-byte tag, read, @len must be 32, 0 back;
+ *     aes256-cbc: 0, and @len comes back 0
+ * @len: see @out
+ * @flags: must be zero
+ */
+struct keycrypt_final {
+       __u64   out;
+       __u32   len;
+       __u32   flags;
+};
+
+#define KEYCRYPT_UPDATE_MAX    65536
+#define KEYCRYPT_MAC_LEN       32
+
+/**
+ * struct keycrypt_info - KEYCRYPT_IOC_INFO argument, written by the kernel
+ * @op: KEYCRYPT_OP_* the context was opened for
+ * @alg: KEYCRYPT_ALG_* of the key
+ * @purpose: KEYCRYPT_PURPOSE_* mask of the key
+ * @tier: KEYCRYPT_TIER_* the key was sealed at
+ * @origin: KEYCRYPT_ORIGIN_*
+ * @accepted_min_tier: the KEYCTL_CRYPT_OPEN @accepted_min_tier the
+ *     context was opened with, 0 for none
+ * @__reserved: zero; a field added here is zero when the kernel does not
+ *     report it, and zero is never one of its values (@accepted_min_tier,
+ *     whose 0 means none, is the exception)
+ * @backend: name of the key's backend, NUL terminated, the rest zero
+ */
+struct keycrypt_info {
+       __u32   op;
+       __u32   alg;
+       __u32   purpose;
+       __u32   tier;
+       __u32   origin;
+       __u32   accepted_min_tier;
+       __u32   __reserved[2];
+       char    backend[32];
+};
+
+#define KEYCRYPT_IOC_MAGIC     0xBB
+#define KEYCRYPT_IOC_UPDATE    _IOW(KEYCRYPT_IOC_MAGIC, 1, struct 
keycrypt_update)
+#define KEYCRYPT_IOC_FINAL     _IOWR(KEYCRYPT_IOC_MAGIC, 2, struct 
keycrypt_final)
+/* 3: KEYCRYPT_IOC_SEGMENT, with the aes256-gcm-stream algorithm */
+#define KEYCRYPT_IOC_INFO      _IOR(KEYCRYPT_IOC_MAGIC, 4, struct 
keycrypt_info)
+
+#endif /* _UAPI_LINUX_KEYCRYPT_H */
diff --git a/include/uapi/linux/keyctl.h b/include/uapi/linux/keyctl.h
index 00cc0942203e..1532cc76ab38 100644
--- a/include/uapi/linux/keyctl.h
+++ b/include/uapi/linux/keyctl.h
@@ -73,6 +73,7 @@
 #define KEYCTL_MOVE                    30      /* Move keys between keyrings */
 #define KEYCTL_CAPABILITIES            31      /* Find capabilities of 
keyrings subsystem */
 #define KEYCTL_WATCH_KEY               32      /* Watch a key or ring of keys 
for changes */
+#define KEYCTL_CRYPT_OPEN              33      /* Open a keycrypt operation 
context */
 
 /* keyctl structures */
 struct keyctl_dh_params {
diff --git a/security/keys/Kconfig b/security/keys/Kconfig
index f4510d8cb485..fb0f48f218ef 100644
--- a/security/keys/Kconfig
+++ b/security/keys/Kconfig
@@ -128,4 +128,6 @@ config KEY_NOTIFICATIONS
          This makes use of pipes to handle the notification buffer and
          provides KEYCTL_WATCH_KEY to enable/disable watches.
 
+source "security/keys/keycrypt/Kconfig"
+
 endif # KEYS
diff --git a/security/keys/Makefile b/security/keys/Makefile
index 5f40807f05b3..82583db1704b 100644
--- a/security/keys/Makefile
+++ b/security/keys/Makefile
@@ -30,3 +30,4 @@ obj-$(CONFIG_ASYMMETRIC_KEY_TYPE) += keyctl_pkey.o
 obj-$(CONFIG_BIG_KEYS) += big_key.o
 obj-$(CONFIG_TRUSTED_KEYS) += trusted-keys/
 obj-$(CONFIG_ENCRYPTED_KEYS) += encrypted-keys/
+obj-$(CONFIG_KEYCRYPT) += keycrypt/
diff --git a/security/keys/compat.c b/security/keys/compat.c
index 1545efdca562..80ea06e59ee2 100644
--- a/security/keys/compat.c
+++ b/security/keys/compat.c
@@ -126,6 +126,9 @@ COMPAT_SYSCALL_DEFINE5(keyctl, u32, option,
        case KEYCTL_WATCH_KEY:
                return keyctl_watch_key(arg2, arg3, arg4);
 
+       case KEYCTL_CRYPT_OPEN:
+               return keyctl_crypt_open(arg2, compat_ptr(arg3), arg4, arg5);
+
        default:
                return -EOPNOTSUPP;
        }
diff --git a/security/keys/internal.h b/security/keys/internal.h
index b7b622bc36a1..69de149a0609 100644
--- a/security/keys/internal.h
+++ b/security/keys/internal.h
@@ -358,6 +358,18 @@ static inline long keyctl_watch_key(key_serial_t key_id, 
int watch_fd, int watch
 }
 #endif
 
+#ifdef CONFIG_KEYCRYPT
+extern long keyctl_crypt_open(key_serial_t id, void __user *uparams,
+                             size_t usize, unsigned long flags);
+#else
+static inline long keyctl_crypt_open(key_serial_t id,
+                                    void __user *uparams,
+                                    size_t usize, unsigned long flags)
+{
+       return -EOPNOTSUPP;
+}
+#endif
+
 /*
  * Debugging key validation
  */
diff --git a/security/keys/keycrypt/Kconfig b/security/keys/keycrypt/Kconfig
new file mode 100644
index 000000000000..e1d1b8e2a58b
--- /dev/null
+++ b/security/keys/keycrypt/Kconfig
@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+config KEYCRYPT
+       bool "Keys user space uses for cryptography but never reads"
+       select CRYPTO_LIB_UTILS
+       help
+         This option provides the "keycrypt" key type: symmetric keys whose
+         algorithm, purpose and protection tier are fixed when they are
+         created, held by a backend such as dedicated hardware or a
+         trusted execution environment. User space keeps only a blob the
+         backend sealed, and never sees a key the backend created; a key
+         of the kernel tier is in clear in kernel memory while loaded.
+
+         See Documentation/security/keys/keycrypt.rst.
+
+         If you are unsure as to whether this is required, answer N.
+
+config KEYCRYPT_IMPORT
+       bool "Allow keycrypt keys to be imported in clear"
+       depends on KEYCRYPT
+       help
+         Allow a process with CAP_SYS_ADMIN to give a keycrypt backend a
+         key in clear, for the backend to seal it ("import"). Such keys
+         existed outside the backend and are marked "imported". Saying N
+         refuses the import command; blobs of keys imported elsewhere
+         still load.
+
+         If you are unsure as to whether this is required, answer N.
+
+choice
+       prompt "System keycrypt tier at boot"
+       default KEYCRYPT_SYSTEM_TIER_KERNEL
+       depends on KEYCRYPT
+       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.
+
+         The default sets no floor: which backends a kernel builds says
+         nothing about which will be present when it runs (a
+         distribution kernel builds them all), so a product that knows
+         its backends raises it here or on its command line.
+
+config KEYCRYPT_SYSTEM_TIER_KERNEL
+       bool "Kernel"
+       help
+         Keys of every tier, the kernel tier included, can be used until
+         the keycrypt.system_tier= boot parameter or the
+         kernel.keys.keycrypt_system_tier sysctl raises the system tier.
+         A system with no backend of the kernel tier built has no key of
+         that tier to use.
+
+config KEYCRYPT_SYSTEM_TIER_TEE
+       bool "TEE"
+       help
+         Keys whose use a trusted execution environment or the hardware
+         checks: keys of the kernel tier are refused at every
+         KEYCTL_CRYPT_OPEN; the tee and hsm tiers can be used. For a
+         system where OP-TEE or an hsm backend holds the keys.
+
+config KEYCRYPT_SYSTEM_TIER_HSM
+       bool "HSM"
+       help
+         Keys whose use dedicated hardware apart from the CPU checks: a
+         key of any tier but hsm is refused at every KEYCTL_CRYPT_OPEN.
+         Choose it only on a system with a backend of the hsm tier, or no
+         keycrypt key can be used at all.
+
+endchoice
diff --git a/security/keys/keycrypt/Makefile b/security/keys/keycrypt/Makefile
new file mode 100644
index 000000000000..8910fb0156e7
--- /dev/null
+++ b/security/keys/keycrypt/Makefile
@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+obj-y += core.o ctx.o
diff --git a/security/keys/keycrypt/core.c b/security/keys/keycrypt/core.c
new file mode 100644
index 000000000000..debd0845621e
--- /dev/null
+++ b/security/keys/keycrypt/core.c
@@ -0,0 +1,1070 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * keycrypt - the key type and the backend registry
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <[email protected]>
+ */
+
+#define pr_fmt(fmt) "keycrypt: " fmt
+
+#include <linux/capability.h>
+#include <linux/err.h>
+#include <linux/hex.h>
+#include <linux/init.h>
+#include <linux/key-type.h>
+#include <linux/kstrtox.h>
+#include <linux/limits.h>
+#include <linux/minmax.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/sysctl.h>
+#include <linux/unaligned.h>
+#include "keycrypt.h"
+
+#define KEYCRYPT_MAGIC         "KCR"
+#define KEYCRYPT_MAGIC_LEN     3
+#define KEYCRYPT_VERSION       1
+
+struct keycrypt_name {
+       u8              value;
+       const char      *name;
+};
+
+static const struct keycrypt_name keycrypt_algs[] = {
+       { KEYCRYPT_ALG_AES256_CBC,      "aes256-cbc" },
+       { KEYCRYPT_ALG_HMAC_SHA256,     "hmac-sha256" },
+};
+
+static const struct keycrypt_name keycrypt_tiers[] = {
+       { KEYCRYPT_TIER_KERNEL,         "kernel" },
+       { KEYCRYPT_TIER_TEE,            "tee" },
+       { KEYCRYPT_TIER_HSM,            "hsm" },
+};
+
+static const struct keycrypt_name keycrypt_origins[] = {
+       { KEYCRYPT_ORIGIN_GENERATED,    "generated" },
+       { KEYCRYPT_ORIGIN_IMPORTED,     "imported" },
+};
+
+static int keycrypt_value(const struct keycrypt_name *t, size_t n,
+                         const char *s)
+{
+       size_t i;
+
+       for (i = 0; i < n; i++)
+               if (!strcmp(t[i].name, s))
+                       return t[i].value;
+       return -EINVAL;
+}
+
+static const char *keycrypt_name(const struct keycrypt_name *t, size_t n,
+                                u8 v)
+{
+       size_t i;
+
+       for (i = 0; i < n; i++)
+               if (t[i].value == v)
+                       return t[i].name;
+       return NULL;
+}
+
+#define KEYCRYPT_VALUE(t, s)   keycrypt_value(t, sizeof(t) / sizeof((t)[0]), s)
+#define KEYCRYPT_NAME(t, v)    keycrypt_name(t, sizeof(t) / sizeof((t)[0]), v)
+
+bool keycrypt_tier_valid(u32 tier)
+{
+       return tier <= U8_MAX && KEYCRYPT_NAME(keycrypt_tiers, tier);
+}
+
+static LIST_HEAD(keycrypt_handles);
+static DEFINE_MUTEX(keycrypt_lock);
+
+static bool keycrypt_purpose_valid(u8 alg, u16 purpose)
+{
+       switch (alg) {
+       case KEYCRYPT_ALG_AES256_CBC:
+               return purpose && !(purpose & ~(KEYCRYPT_PURPOSE_ENCRYPT |
+                                               KEYCRYPT_PURPOSE_DECRYPT));
+       case KEYCRYPT_ALG_HMAC_SHA256:
+               return purpose && !(purpose & ~(KEYCRYPT_PURPOSE_MAC |
+                                               KEYCRYPT_PURPOSE_VERIFY));
+       }
+       return false;
+}
+
+/* [a-z0-9_-], ASCII only: islower() also accepts Latin-1 letters */
+static bool keycrypt_name_valid(const char *s, size_t n)
+{
+       size_t i;
+
+       if (!n || n > KEYCRYPT_BACKEND_NAME_MAX)
+               return false;
+       for (i = 0; i < n; i++)
+               if (!((s[i] >= 'a' && s[i] <= 'z') ||
+                     (s[i] >= '0' && s[i] <= '9') || s[i] == '-' ||
+                     s[i] == '_'))
+                       return false;
+       return true;
+}
+
+static char *keycrypt_next_token(char **s)
+{
+       char *t;
+
+       do {
+               t = strsep(s, " \t\n");
+       } while (t && !*t);
+       return t;
+}
+
+static int keycrypt_parse_purpose(char *s, u16 *purpose)
+{
+       char *p;
+
+       *purpose = 0;
+       while ((p = strsep(&s, ",")) != NULL) {
+               u16 bit;
+
+               if (!strcmp(p, "encrypt"))
+                       bit = KEYCRYPT_PURPOSE_ENCRYPT;
+               else if (!strcmp(p, "decrypt"))
+                       bit = KEYCRYPT_PURPOSE_DECRYPT;
+               else if (!strcmp(p, "mac"))
+                       bit = KEYCRYPT_PURPOSE_MAC;
+               else if (!strcmp(p, "verify"))
+                       bit = KEYCRYPT_PURPOSE_VERIFY;
+               else
+                       return -EINVAL;
+               if (*purpose & bit)
+                       return -EINVAL;
+               *purpose |= bit;
+       }
+       return 0;
+}
+
+static int keycrypt_parse_tier(const char *s, u8 *tier)
+{
+       int n;
+
+       if (*tier)
+               return -EINVAL;
+       n = KEYCRYPT_VALUE(keycrypt_tiers, s);
+       if (n < 0)
+               return n;
+       *tier = n;
+       return 0;
+}
+
+static int keycrypt_add_opt(struct keycrypt_req *req, const char *t)
+{
+       size_t len = strlen(req->opts), n = strlen(t);
+
+       if (len + 1 + n + 1 > req->opts_size)
+               return -EINVAL;
+       if (len)
+               req->opts[len++] = ' ';
+       memcpy(req->opts + len, t, n + 1);
+       return 0;
+}
+
+static int keycrypt_parse_option(char *t, struct keycrypt_req *req)
+{
+       char *v = strchr(t, '=');
+       bool load = req->cmd == KEYCRYPT_CMD_LOAD;
+
+       if (v == t || !v[1])
+               return -EINVAL;
+       *v++ = '\0';
+       if (!strcmp(t, "accepted-min-tier"))
+               return load ? keycrypt_parse_tier(v, &req->accepted_min_tier) :
+                             -EINVAL;
+       if (!strcmp(t, "backend")) {
+               if (load || *req->backend || !keycrypt_name_valid(v, strlen(v)))
+                       return -EINVAL;
+               strscpy(req->backend, v);
+               return 0;
+       }
+       if (!strcmp(t, "min-tier"))
+               return load ? -EINVAL : keycrypt_parse_tier(v, &req->min_tier);
+       if (!strcmp(t, "purpose")) {
+               if (!load || req->want_purpose)
+                       return -EINVAL;
+               if (keycrypt_parse_purpose(v, &req->want_purpose))
+                       return -EINVAL;
+               if (!keycrypt_purpose_valid(KEYCRYPT_ALG_AES256_CBC,
+                                           req->want_purpose) &&
+                   !keycrypt_purpose_valid(KEYCRYPT_ALG_HMAC_SHA256,
+                                           req->want_purpose))
+                       return -EINVAL;
+               return 0;
+       }
+       if (!strcmp(t, "tier"))
+               return load ? -EINVAL : keycrypt_parse_tier(v, &req->tier);
+       v[-1] = '=';
+       return keycrypt_add_opt(req, t);
+}
+
+/*
+ * "new <alg> <purpose>[,<purpose>...] [<option>=<value>...]"
+ * "import <alg> <purpose>[,<purpose>...] [<option>=<value>...] <hex key>"
+ * "load <hex blob> [<option>=<value>...]"
+ *
+ * req->opts and req->opts_size must be set by the caller.
+ */
+static int keycrypt_parse(char *s, struct keycrypt_req *req)
+{
+       size_t opts_size = req->opts_size;
+       char *opts = req->opts;
+       char *t;
+       int n, ret;
+
+       memset(req, 0, sizeof(*req));
+       req->opts = opts;
+       req->opts_size = opts_size;
+       opts[0] = '\0';
+
+       t = keycrypt_next_token(&s);
+       if (!t)
+               return -EINVAL;
+       if (!strcmp(t, "load")) {
+               req->cmd = KEYCRYPT_CMD_LOAD;
+               req->hex = keycrypt_next_token(&s);
+               if (!req->hex)
+                       return -EINVAL;
+               while ((t = keycrypt_next_token(&s)) != NULL) {
+                       if (!strchr(t, '='))
+                               return -EINVAL;
+                       ret = keycrypt_parse_option(t, req);
+                       if (ret)
+                               return ret;
+               }
+               return 0;
+       }
+       if (!strcmp(t, "new"))
+               req->cmd = KEYCRYPT_CMD_NEW;
+       else if (!strcmp(t, "import"))
+               req->cmd = KEYCRYPT_CMD_IMPORT;
+       else
+               return -EINVAL;
+
+       t = keycrypt_next_token(&s);
+       if (!t)
+               return -EINVAL;
+       n = KEYCRYPT_VALUE(keycrypt_algs, t);
+       if (n < 0)
+               return n;
+       req->alg = n;
+
+       t = keycrypt_next_token(&s);
+       if (!t)
+               return -EINVAL;
+       ret = keycrypt_parse_purpose(t, &req->purpose);
+       if (ret)
+               return ret;
+       if (!keycrypt_purpose_valid(req->alg, req->purpose))
+               return -EINVAL;
+
+       while ((t = keycrypt_next_token(&s)) != NULL) {
+               if (req->hex)
+                       return -EINVAL;
+               if (strchr(t, '=')) {
+                       ret = keycrypt_parse_option(t, req);
+                       if (ret)
+                               return ret;
+                       continue;
+               }
+               if (req->cmd != KEYCRYPT_CMD_IMPORT)
+                       return -EINVAL;
+               req->hex = t;
+       }
+       if (req->tier && req->min_tier)
+               return -EINVAL;
+       if (req->cmd == KEYCRYPT_CMD_IMPORT && !req->hex)
+               return -EINVAL;
+       return 0;
+}
+
+static int keycrypt_meta_header(const struct keycrypt_meta *m,
+                               u8 *buf, size_t len)
+{
+       size_t n = strnlen(m->backend, sizeof(m->backend));
+       size_t need = KEYCRYPT_HEADER_FIXED + n;
+
+       if (!keycrypt_name_valid(m->backend, n))
+               return -EINVAL;
+       if (len < need)
+               return -ENOSPC;
+       memcpy(buf, KEYCRYPT_MAGIC, KEYCRYPT_MAGIC_LEN);
+       buf[3] = KEYCRYPT_VERSION;
+       buf[4] = 0;
+       buf[5] = m->alg;
+       put_unaligned_le16(m->purpose, buf + 6);
+       buf[8] = m->tier;
+       buf[9] = m->origin;
+       buf[10] = n;
+       memcpy(buf + KEYCRYPT_HEADER_FIXED, m->backend, n);
+       return need;
+}
+
+static void keycrypt_payload_init(struct keycrypt_payload *p,
+                                 const struct keycrypt_meta *m,
+                                 u32 hdr_len, u32 data_len)
+{
+       INIT_LIST_HEAD(&p->node);
+       p->key.meta = *m;
+       p->key.hdr = p->blob;
+       p->key.hdr_len = hdr_len;
+       p->key.data = p->blob + hdr_len + 4;
+       p->key.data_len = data_len;
+       p->blob_len = hdr_len + 4 + data_len;
+}
+
+static int keycrypt_payload_build(const struct keycrypt_meta *m,
+                                 const u8 *hdr, u32 hdr_len,
+                                 const u8 *data, u32 len,
+                                 struct keycrypt_payload **out)
+{
+       struct keycrypt_payload *p;
+
+       if (!data || !len || len > KEYCRYPT_BACKEND_DATA_MAX)
+               return -EIO;
+       p = kzalloc_flex(*p, blob, hdr_len + 4 + len);
+       if (!p)
+               return -ENOMEM;
+       memcpy(p->blob, hdr, hdr_len);
+       put_unaligned_le32(len, p->blob + hdr_len);
+       memcpy(p->blob + hdr_len + 4, data, len);
+       keycrypt_payload_init(p, m, hdr_len, len);
+       *out = p;
+       return 0;
+}
+
+static int keycrypt_payload_parse(const u8 *raw, size_t len,
+                                 struct keycrypt_payload **out)
+{
+       struct keycrypt_meta m = {};
+       struct keycrypt_payload *p;
+       size_t n, off;
+       u32 dlen;
+
+       if (len < KEYCRYPT_HEADER_FIXED ||
+           memcmp(raw, KEYCRYPT_MAGIC, KEYCRYPT_MAGIC_LEN))
+               return -EBADMSG;
+       if (raw[3] != KEYCRYPT_VERSION || raw[4])
+               return -EOPNOTSUPP;
+       m.alg = raw[5];
+       m.purpose = get_unaligned_le16(raw + 6);
+       m.tier = raw[8];
+       m.origin = raw[9];
+       n = raw[10];
+       if (!keycrypt_purpose_valid(m.alg, m.purpose) ||
+           !keycrypt_tier_valid(m.tier) ||
+           !KEYCRYPT_NAME(keycrypt_origins, m.origin))
+               return -EBADMSG;
+       off = KEYCRYPT_HEADER_FIXED + n;
+       /* The name is read only once the length covers it */
+       if (len < off + 4 ||
+           !keycrypt_name_valid((const char *)raw + KEYCRYPT_HEADER_FIXED, n))
+               return -EBADMSG;
+       memcpy(m.backend, raw + KEYCRYPT_HEADER_FIXED, n);
+       dlen = get_unaligned_le32(raw + off);
+       if (!dlen || dlen > KEYCRYPT_BACKEND_DATA_MAX || len != off + 4 + dlen)
+               return -EBADMSG;
+
+       p = kzalloc_flex(*p, blob, len);
+       if (!p)
+               return -ENOMEM;
+       memcpy(p->blob, raw, len);
+       keycrypt_payload_init(p, &m, off, dlen);
+       *out = p;
+       return 0;
+}
+
+void keycrypt_handle_put(struct keycrypt_handle *h)
+{
+       if (refcount_dec_and_test(&h->ref))
+               kfree(h);
+}
+
+/**
+ * keycrypt_register_backend() - make a backend available to keys
+ * @b: the backend, valid until keycrypt_unregister_backend() returns
+ *
+ * Return: 0, -EINVAL for a malformed @b, -EBUSY for a @b already
+ * registered, -EEXIST for a name in use, -ENOMEM.
+ */
+int keycrypt_register_backend(struct keycrypt_backend *b)
+{
+       struct keycrypt_handle *h, *p;
+       int ret = 0;
+
+       if (!b->name ||
+           !keycrypt_name_valid(b->name,
+                                strnlen(b->name,
+                                        KEYCRYPT_BACKEND_NAME_MAX + 1)) ||
+           !keycrypt_tier_valid(b->tier) ||
+           !b->algs || (b->algs & ~KEYCRYPT_ALGS_ALL) ||
+           !b->generate || !b->load ||
+           ((!!b->ctx_open + !!b->update + !!b->final + !!b->ctx_free) % 4) ||
+           (b->tier >= KEYCRYPT_TIER_TEE &&
+            b->ctx_open &&
+            (b->algs & BIT(KEYCRYPT_ALG_HMAC_SHA256)) && !b->verify))
+               return -EINVAL;
+
+       h = kzalloc_obj(*h);
+       if (!h)
+               return -ENOMEM;
+       refcount_set(&h->ref, 1);
+       init_rwsem(&h->sem);
+       mutex_init(&h->keys_lock);
+       INIT_LIST_HEAD(&h->keys);
+       INIT_LIST_HEAD(&h->ctxs);
+       h->b = b;
+       h->tier = b->tier;
+       strscpy(h->name, b->name);
+
+       mutex_lock(&keycrypt_lock);
+       if (b->handle)
+               ret = -EBUSY;
+       if (!ret)
+               list_for_each_entry(p, &keycrypt_handles, list) {
+                       if (!strcmp(p->name, h->name)) {
+                               ret = -EEXIST;
+                               break;
+                       }
+               }
+       if (!ret) {
+               list_add_tail(&h->list, &keycrypt_handles);
+               b->handle = h;
+       }
+       mutex_unlock(&keycrypt_lock);
+       if (ret)
+               kfree(h);
+       return ret;
+}
+EXPORT_SYMBOL_GPL(keycrypt_register_backend);
+
+/*
+ * The one door to @b->destroy: at most once per key, with @p's handle's
+ * sem held for writing (revoke, unregister) or by keycrypt_payload_free()
+ * when nothing else can reach @p, and its keys_lock held.
+ */
+static void keycrypt_payload_destroy(struct keycrypt_backend *b,
+                                    struct keycrypt_payload *p)
+{
+       if (p->destroyed)
+               return;
+       p->destroyed = true;
+       if (b && b->destroy)
+               b->destroy(b, &p->key);
+}
+
+/**
+ * keycrypt_unregister_backend() - remove a backend
+ * @b: a backend registered earlier
+ *
+ * Waits for the backend calls in progress, calls @b->destroy on every key
+ * still using it, and leaves those keys in place: from then on they fail
+ * with -ENODEV. @b may be freed once this returns.
+ */
+void keycrypt_unregister_backend(struct keycrypt_backend *b)
+{
+       struct keycrypt_handle *h;
+       struct keycrypt_payload *p;
+       struct keycrypt_ctx *c;
+
+       mutex_lock(&keycrypt_lock);
+       h = b->handle;
+       if (WARN_ON_ONCE(!h)) {
+               mutex_unlock(&keycrypt_lock);
+               return;
+       }
+       b->handle = NULL;
+       list_del(&h->list);
+       mutex_unlock(&keycrypt_lock);
+
+       down_write(&h->sem);
+       mutex_lock(&h->keys_lock);
+       /* Contexts before keys, the order keycrypt_payload_revoke() uses */
+       list_for_each_entry(c, &h->ctxs, node)
+               keycrypt_ctx_detach(b, c);
+       list_for_each_entry(p, &h->keys, node)
+               keycrypt_payload_destroy(b, p);
+       mutex_unlock(&h->keys_lock);
+       h->b = NULL;
+       up_write(&h->sem);
+
+       keycrypt_handle_put(h);
+}
+EXPORT_SYMBOL_GPL(keycrypt_unregister_backend);
+
+/*
+ * The best backend for @alg (and, for @import, with an import) meeting
+ * every constraint given: named @name, of tier @tier, of at least
+ * @min_tier; the highest tier wins, the smaller name on a tie. Returned
+ * with a reference.
+ */
+static struct keycrypt_handle *keycrypt_get_handle(const char *name, u8 tier,
+                                                  u8 min_tier, u8 alg,
+                                                  bool import)
+{
+       struct keycrypt_handle *h, *best = NULL;
+
+       mutex_lock(&keycrypt_lock);
+       list_for_each_entry(h, &keycrypt_handles, list) {
+               if (!(h->b->algs & BIT(alg)) || (import && !h->b->import))
+                       continue;
+               if (name && strcmp(h->name, name))
+                       continue;
+               if ((tier && h->tier != tier) || h->tier < min_tier)
+                       continue;
+               if (!best || h->tier > best->tier ||
+                   (h->tier == best->tier && strcmp(h->name, best->name) < 0))
+                       best = h;
+       }
+       if (best)
+               refcount_inc(&best->ref);
+       mutex_unlock(&keycrypt_lock);
+       return best;
+}
+
+/* What a backend's error becomes for user space */
+int keycrypt_backend_ret(int ret)
+{
+       switch (ret) {
+       case 0:
+       case -ENOMEM:
+       case -EINVAL:
+       case -EBADMSG:
+       case -ENOKEY:
+       case -EKEYREJECTED:
+       case -EACCES:
+       case -EINTR:
+       case -ERESTARTSYS:
+               return ret;
+       }
+       return -EIO;
+}
+
+static const char *keycrypt_opts(const struct keycrypt_req *req)
+{
+       return *req->opts ? req->opts : NULL;
+}
+
+/* Every option in @opts has a key @b declares, and no key comes twice */
+static int keycrypt_check_opts(const struct keycrypt_backend *b,
+                              const char *opts)
+{
+       const char *s = opts, *e, *eq;
+       unsigned long seen = 0;
+       size_t i, n;
+
+       if (!opts)
+               return 0;
+       while (*s) {
+               e = strchrnul(s, ' ');
+               eq = strnchr(s, e - s, '=');
+               n = eq ? eq - s : e - s;
+               for (i = 0; b->opts && b->opts[i]; i++)
+                       if (strlen(b->opts[i]) == n &&
+                           !strncmp(b->opts[i], s, n))
+                               break;
+               if (!b->opts || !b->opts[i] || i >= BITS_PER_LONG ||
+                   (seen & BIT(i)))
+                       return -EINVAL;
+               seen |= BIT(i);
+               s = *e ? e + 1 : e;
+       }
+       return 0;
+}
+
+/*
+ * Let the backend accept @p and link it to @h. Called with @h->sem held
+ * for reading and @h->b set; on success @p keeps the caller's reference
+ * to @h.
+ */
+static int keycrypt_attach(struct keycrypt_handle *h,
+                          struct keycrypt_payload *p, const char *opts)
+{
+       struct keycrypt_backend *b = h->b;
+       int ret;
+
+       if (!try_module_get(b->owner))
+               return -ENODEV;
+       ret = keycrypt_backend_ret(b->load(b, &p->key, opts));
+       if (ret) {
+               module_put(b->owner);
+               return ret;
+       }
+       p->handle = h;
+       p->owner = b->owner;
+       mutex_lock(&h->keys_lock);
+       list_add(&p->node, &h->keys);
+       mutex_unlock(&h->keys_lock);
+       return 0;
+}
+
+static void keycrypt_payload_free(struct keycrypt_payload *p)
+{
+       struct keycrypt_handle *h;
+
+       if (!p)
+               return;
+       h = p->handle;
+       if (h) {
+               down_read(&h->sem);
+               mutex_lock(&h->keys_lock);
+               keycrypt_payload_destroy(h->b, p);
+               list_del(&p->node);
+               mutex_unlock(&h->keys_lock);
+               up_read(&h->sem);
+               module_put(p->owner);
+               keycrypt_handle_put(h);
+       }
+       kfree_sensitive(p);
+}
+
+struct keycrypt_policy keycrypt_policy = {
+       .lock           = __MUTEX_INITIALIZER(keycrypt_policy.lock),
+       .system_tier    = KEYCRYPT_BOOT_SYSTEM_TIER,
+       .import         = true,
+};
+
+/* -EINVAL for an unknown tier, -EPERM for a lower one; equal is a no-op */
+static int
+keycrypt_policy_set_system_tier(struct keycrypt_policy *pol, u8 tier)
+{
+       int ret = 0;
+
+       if (!keycrypt_tier_valid(tier))
+               return -EINVAL;
+       mutex_lock(&pol->lock);
+       if (tier < pol->system_tier)
+               ret = -EPERM;
+       else
+               WRITE_ONCE(pol->system_tier, tier);
+       mutex_unlock(&pol->lock);
+       return ret;
+}
+
+/* -EPERM for turning it back on; off twice is a no-op */
+static int keycrypt_policy_set_import(struct keycrypt_policy *pol,
+                                     bool on)
+{
+       int ret = 0;
+
+       mutex_lock(&pol->lock);
+       if (on && !pol->import)
+               ret = -EPERM;
+       else
+               WRITE_ONCE(pol->import, on);
+       mutex_unlock(&pol->lock);
+       return ret;
+}
+
+u8 keycrypt_policy_system_tier(void)
+{
+       return READ_ONCE(keycrypt_policy.system_tier);
+}
+
+bool keycrypt_policy_import(void)
+{
+       return READ_ONCE(keycrypt_policy.import);
+}
+
+static int keycrypt_create(const struct keycrypt_req *req,
+                          struct keycrypt_payload **out)
+{
+       bool import = req->cmd == KEYCRYPT_CMD_IMPORT;
+       const char *opts = keycrypt_opts(req);
+       struct keycrypt_payload *p = NULL;
+       struct keycrypt_blob blob = {};
+       struct keycrypt_meta m = {};
+       u8 hdr[KEYCRYPT_HEADER_MAX];
+       struct keycrypt_handle *h;
+       struct keycrypt_backend *b;
+       size_t keylen = 0;
+       u8 *key = NULL;
+       int hlen, ret;
+
+       if (import) {
+               if (!IS_ENABLED(CONFIG_KEYCRYPT_IMPORT) ||
+                   !keycrypt_policy_import() || !capable(CAP_SYS_ADMIN))
+                       return -EPERM;
+               keylen = strlen(req->hex);
+               if (keylen % 2)
+                       return -EINVAL;
+               keylen /= 2;
+               if (!keycrypt_key_len_valid(req->alg, keylen))
+                       return -EINVAL;
+               key = kmalloc(keylen, GFP_KERNEL);
+               if (!key)
+                       return -ENOMEM;
+               if (hex2bin(key, req->hex, keylen)) {
+                       ret = -EINVAL;
+                       goto out;
+               }
+       }
+
+       h = keycrypt_get_handle(*req->backend ? req->backend : NULL, req->tier,
+                               req->min_tier, req->alg, import);
+       if (!h) {
+               ret = -ENODEV;
+               goto out;
+       }
+       down_read(&h->sem);
+       b = h->b;
+       if (!b) {
+               ret = -ENODEV;
+               goto unlock;
+       }
+       ret = keycrypt_check_opts(b, opts);
+       if (ret)
+               goto unlock;
+
+       m.alg = req->alg;
+       m.purpose = req->purpose;
+       m.tier = h->tier;
+       m.origin = import ? KEYCRYPT_ORIGIN_IMPORTED :
+                           KEYCRYPT_ORIGIN_GENERATED;
+       strscpy(m.backend, h->name);
+       hlen = keycrypt_meta_header(&m, hdr, sizeof(hdr));
+       if (hlen < 0) {
+               ret = hlen;
+               goto unlock;
+       }
+
+       if (import)
+               ret = b->import(b, &m, hdr, hlen, opts, key, keylen, &blob);
+       else
+               ret = b->generate(b, &m, hdr, hlen, opts, &blob);
+       ret = keycrypt_backend_ret(ret);
+       if (!ret)
+               ret = keycrypt_payload_build(&m, hdr, hlen, blob.data, blob.len,
+                                            &p);
+       kfree_sensitive(blob.data);
+       /* load options come only with "load": none for the new blob */
+       if (!ret)
+               ret = keycrypt_attach(h, p, NULL);
+       if (ret) {
+               kfree_sensitive(p);
+               p = NULL;
+       }
+unlock:
+       up_read(&h->sem);
+       if (ret)
+               keycrypt_handle_put(h);
+       else
+               *out = p;
+out:
+       kfree_sensitive(key);
+       return ret;
+}
+
+static int keycrypt_load(const struct keycrypt_req *req,
+                        struct keycrypt_payload **out)
+{
+       size_t len = strlen(req->hex);
+       struct keycrypt_handle *h;
+       struct keycrypt_payload *p;
+       struct keycrypt_meta *m;
+       u8 *raw;
+       int ret;
+
+       if (!len || len % 2 || len / 2 > KEYCRYPT_BLOB_MAX)
+               return -EINVAL;
+       raw = kmalloc(len / 2, GFP_KERNEL);
+       if (!raw)
+               return -ENOMEM;
+       ret = hex2bin(raw, req->hex, len / 2) ? -EINVAL : 0;
+       if (!ret)
+               ret = keycrypt_payload_parse(raw, len / 2, &p);
+       kfree_sensitive(raw);
+       if (ret)
+               return ret;
+
+       m = &p->key.meta;
+       h = keycrypt_get_handle(m->backend, 0, 0, m->alg, false);
+       if (!h) {
+               ret = -ENODEV;
+               goto free;
+       }
+       down_read(&h->sem);
+       if (!h->b)
+               ret = -ENODEV;
+       else if (m->tier > h->tier)
+               ret = -EKEYREJECTED;
+       else if (m->tier < req->accepted_min_tier)
+               ret = -EPERM;
+       else if (req->want_purpose && m->purpose != req->want_purpose)
+               ret = -EKEYREJECTED;
+       else if (keycrypt_check_opts(h->b, keycrypt_opts(req)))
+               ret = -EINVAL;
+       else
+               ret = keycrypt_attach(h, p, keycrypt_opts(req));
+       up_read(&h->sem);
+       if (!ret) {
+               *out = p;
+               return 0;
+       }
+       keycrypt_handle_put(h);
+free:
+       kfree_sensitive(p);
+       return ret;
+}
+
+static int keycrypt_preparse(struct key_preparsed_payload *prep)
+{
+       struct keycrypt_payload *p = NULL;
+       struct keycrypt_req req = {};
+       char *buf, *opts;
+       int ret;
+
+       if (!prep->data || !prep->datalen ||
+           prep->datalen > KEYCRYPT_INPUT_MAX)
+               return -EINVAL;
+       /* A NUL would hide what follows it; a final one is tolerated */
+       if (memchr(prep->data, '\0', prep->datalen - 1))
+               return -EINVAL;
+
+       buf = kmemdup_nul(prep->data, prep->datalen, GFP_KERNEL);
+       opts = kzalloc(prep->datalen + 1, GFP_KERNEL);
+       if (!buf || !opts) {
+               ret = -ENOMEM;
+               goto out;
+       }
+       req.opts = opts;
+       req.opts_size = prep->datalen + 1;
+       ret = keycrypt_parse(buf, &req);
+       if (!ret) {
+               if (req.cmd == KEYCRYPT_CMD_LOAD)
+                       ret = keycrypt_load(&req, &p);
+               else
+                       ret = keycrypt_create(&req, &p);
+       }
+out:
+       kfree_sensitive(opts);
+       kfree_sensitive(buf);           /* it may hold a key in clear */
+       if (ret)
+               return ret;
+       prep->payload.data[0] = p;
+       prep->quotalen = p->blob_len;
+       return 0;
+}
+
+static void keycrypt_free_preparse(struct key_preparsed_payload *prep)
+{
+       keycrypt_payload_free(prep->payload.data[0]);
+}
+
+static void keycrypt_destroy(struct key *key)
+{
+       keycrypt_payload_free(key->payload.data[0]);
+}
+
+/* What "keyctl read" returns: the blob in hex, what "load" takes */
+static long keycrypt_format(const struct keycrypt_payload *p,
+                           char *buf, size_t buflen)
+{
+       long len = 2 * p->blob_len;
+       char *txt;
+
+       if (!buf || !buflen)
+               return len;
+       if (buflen >= len) {
+               bin2hex(buf, p->blob, p->blob_len);
+               return len;
+       }
+       txt = kmalloc(len, GFP_KERNEL);
+       if (!txt)
+               return -ENOMEM;
+       bin2hex(txt, p->blob, p->blob_len);
+       memcpy(buf, txt, buflen);
+       kfree(txt);
+       return len;
+}
+
+static long keycrypt_read(const struct key *key, char *buffer, size_t buflen)
+{
+       return keycrypt_format(dereference_key_locked(key), buffer, buflen);
+}
+
+static void keycrypt_purpose_str(u16 purpose, char *buf, size_t len)
+{
+       static const char * const names[] = {
+               "encrypt", "decrypt", "mac", "verify"
+       };
+       size_t i, n = 0;
+
+       buf[0] = '\0';
+       for (i = 0; i < ARRAY_SIZE(names); i++)
+               if (purpose & BIT(i))
+                       n += scnprintf(buf + n, len - n, "%s%s", n ? "," : "",
+                                      names[i]);
+}
+
+/* "<description>: <alg> <purpose> <tier> <backend> <origin>" */
+static void keycrypt_describe(const struct key *key, struct seq_file *m)
+{
+       const struct keycrypt_payload *p;
+       char purpose[24];
+
+       seq_puts(m, key->description);
+       if (!key_is_positive(key))
+               return;
+       p = dereference_key_rcu(key);
+       if (!p)
+               return;
+       keycrypt_purpose_str(p->key.meta.purpose, purpose, sizeof(purpose));
+       seq_printf(m, ": %s %s %s %s %s",
+                  KEYCRYPT_NAME(keycrypt_algs, p->key.meta.alg), purpose,
+                  KEYCRYPT_NAME(keycrypt_tiers, p->key.meta.tier),
+                  p->key.meta.backend,
+                  KEYCRYPT_NAME(keycrypt_origins, p->key.meta.origin));
+}
+
+/*
+ * Detach every open context of @key and wipe the backend's state for it.
+ * h->sem is taken for writing so that no backend call is still running on
+ * those contexts; lock order: key->sem, h->sem, h->keys_lock. Safe to call
+ * twice.
+ */
+static void keycrypt_payload_revoke(struct keycrypt_payload *p,
+                                   struct key *key)
+{
+       struct keycrypt_handle *h;
+
+       if (!p || !p->handle)
+               return;
+       h = p->handle;
+       down_write(&h->sem);
+       mutex_lock(&h->keys_lock);
+       keycrypt_ctx_revoke(h, key);    /* detaches c->key == key */
+       keycrypt_payload_destroy(h->b, p);
+       mutex_unlock(&h->keys_lock);
+       up_write(&h->sem);
+}
+
+static void keycrypt_revoke(struct key *key)
+{
+       keycrypt_payload_revoke(dereference_key_locked(key), key);
+}
+
+/*
+ * Never constructed on demand: a request-key helper would instantiate the
+ * key with its own credentials and keyrings, not the requester's. The key
+ * is negated here, so every caller gets -ENOKEY.
+ */
+static int keycrypt_request_key(struct key *authkey, void *aux)
+{
+       complete_request_key(authkey, -ENOKEY);
+       return 0;
+}
+
+/*
+ * No .update: a payload never changes once instantiated, which .revoke and
+ * keyctl_crypt_open() rely on when they read it without key->sem.
+ */
+struct key_type key_type_keycrypt = {
+       .name           = "keycrypt",
+       .request_key    = keycrypt_request_key,
+       .preparse       = keycrypt_preparse,
+       .free_preparse  = keycrypt_free_preparse,
+       .instantiate    = generic_key_instantiate,
+       .destroy        = keycrypt_destroy,
+       .describe       = keycrypt_describe,
+       .read           = keycrypt_read,
+       .revoke         = keycrypt_revoke,
+};
+
+/*
+ * System policies: the kernel.keys sysctls
+ */
+
+static int keycrypt_sysctl_system_tier(const struct ctl_table *table,
+                                      int write, void *buf, size_t *lenp,
+                                      loff_t *ppos)
+{
+       unsigned int v = keycrypt_policy_system_tier();
+       const struct ctl_table t = { .data = &v, .maxlen = sizeof(v) };
+       int ret;
+
+       if (write && !capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       ret = proc_douintvec(&t, write, buf, lenp, ppos);
+       if (ret || !write)
+               return ret;
+       return keycrypt_policy_set_system_tier(&keycrypt_policy,
+                                              v > U8_MAX ? U8_MAX : v);
+}
+
+static int keycrypt_sysctl_import(const struct ctl_table *table, int write,
+                                 void *buf, size_t *lenp, loff_t *ppos)
+{
+       unsigned int v = keycrypt_policy_import();
+       const struct ctl_table t = { .data = &v, .maxlen = sizeof(v) };
+       int ret;
+
+       if (write && !capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       ret = proc_douintvec(&t, write, buf, lenp, ppos);
+       if (ret || !write)
+               return ret;
+       if (v > 1)
+               return -EINVAL;
+       return keycrypt_policy_set_import(&keycrypt_policy, v);
+}
+
+static const struct ctl_table keycrypt_sysctls[] = {
+       {
+               .procname       = "keycrypt_system_tier",
+               .mode           = 0644,
+               .proc_handler   = keycrypt_sysctl_system_tier,
+       },
+       {
+               .procname       = "keycrypt_import",
+               .mode           = 0644,
+               .proc_handler   = keycrypt_sysctl_import,
+       },
+};
+
+/*
+ * System policies: the boot parameters
+ */
+
+static int __init keycrypt_system_tier_setup(char *s)
+{
+       u8 tier = 0;
+
+       if (keycrypt_parse_tier(s, &tier) ||
+           keycrypt_policy_set_system_tier(&keycrypt_policy, tier))
+               pr_warn("ignoring keycrypt.system_tier=%s\n", s);
+       return 1;
+}
+__setup("keycrypt.system_tier=", keycrypt_system_tier_setup);
+
+static int __init keycrypt_import_setup(char *s)
+{
+       bool on;
+
+       if (kstrtobool(s, &on) ||
+           keycrypt_policy_set_import(&keycrypt_policy, on))
+               pr_warn("ignoring keycrypt.import=%s\n", s);
+       return 1;
+}
+__setup("keycrypt.import=", keycrypt_import_setup);
+
+static int __init keycrypt_init(void)
+{
+       int ret = register_key_type(&key_type_keycrypt);
+
+       if (ret)
+               return ret;
+       /* register_sysctl_init() logs and does not fail: defaults still work */
+       register_sysctl_init("kernel/keys", keycrypt_sysctls);
+       return 0;
+}
+late_initcall(keycrypt_init);
diff --git a/security/keys/keycrypt/ctx.c b/security/keys/keycrypt/ctx.c
new file mode 100644
index 000000000000..ce62ba08479b
--- /dev/null
+++ b/security/keys/keycrypt/ctx.c
@@ -0,0 +1,530 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * keycrypt - the operation context: KEYCTL_CRYPT_OPEN and its fd
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <[email protected]>
+ */
+
+#include <crypto/aes.h>
+#include <crypto/utils.h>
+#include <linux/anon_inodes.h>
+#include <linux/build_bug.h>
+#include <linux/err.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/key.h>
+#include <linux/keyctl.h>
+#include <linux/limits.h>
+#include <linux/minmax.h>
+#include <linux/mm.h>
+#include <linux/random.h>
+#include <linux/slab.h>
+#include <linux/stddef.h>
+#include <linux/string.h>
+#include <linux/uaccess.h>
+#include <uapi/linux/keycrypt.h>
+#include "../internal.h"
+#include "keycrypt.h"
+
+static_assert(offsetofend(struct keycrypt_open_params, iv) ==
+             KEYCRYPT_OPEN_PARAMS_SIZE_VER0);
+static_assert(KEYCRYPT_BACKEND_NAME_MAX <
+             sizeof_field(struct keycrypt_info, backend));
+
+static const u16 keycrypt_op_purpose[] = {
+       [KEYCRYPT_OP_ENCRYPT]   = KEYCRYPT_PURPOSE_ENCRYPT,
+       [KEYCRYPT_OP_DECRYPT]   = KEYCRYPT_PURPOSE_DECRYPT,
+       [KEYCRYPT_OP_MAC]       = KEYCRYPT_PURPOSE_MAC,
+       [KEYCRYPT_OP_VERIFY]    = KEYCRYPT_PURPOSE_MAC | 
KEYCRYPT_PURPOSE_VERIFY,
+};
+
+/*
+ * A context callback's error as user space sees it; keycrypt_backend_ret()
+ * is the wider mapping of @generate, @import and @load
+ */
+static int keycrypt_ctx_ret(int ret)
+{
+       switch (ret) {
+       case 0:
+       case -ENOMEM:
+       case -EINTR:
+       case -ERESTARTSYS:
+       case -EBADMSG:
+               return ret;
+       }
+       return -EIO;
+}
+
+/*
+ * Release the backend's state of @c. Called with @c->h->sem held (for
+ * writing by unregister and by revoke, with @b the backend; for reading
+ * otherwise, with @b = @c->h->b) and @c->h->keys_lock held. Leaves @done
+ * untouched: a detached @c with @bctx NULL answers through
+ * keycrypt_ctx_backend() instead of ending.
+ */
+void keycrypt_ctx_detach(struct keycrypt_backend *b, struct keycrypt_ctx *c)
+{
+       if (c->bctx && b)
+               b->ctx_free(b, c->bctx);
+       c->bctx = NULL;
+}
+
+/*
+ * Detach every context of @key: called by key_type_keycrypt.revoke(), with
+ * @h->sem held for writing and @h->keys_lock held. Left in @h->ctxs: only
+ * the fd's release removes a context from the list.
+ */
+void keycrypt_ctx_revoke(struct keycrypt_handle *h, struct key *key)
+{
+       struct keycrypt_ctx *c;
+
+       list_for_each_entry(c, &h->ctxs, node)
+               if (c->key == key)
+                       keycrypt_ctx_detach(h->b, c);
+}
+
+/* Detach @c from its backend and from the handle's list */
+static void keycrypt_ctx_drop(struct keycrypt_ctx *c)
+{
+       struct keycrypt_handle *h = c->h;
+
+       down_read(&h->sem);
+       mutex_lock(&h->keys_lock);
+       keycrypt_ctx_detach(h->b, c);
+       list_del_init(&c->node);
+       mutex_unlock(&h->keys_lock);
+       up_read(&h->sem);
+}
+
+static void keycrypt_ctx_free(struct keycrypt_ctx *c)
+{
+       keycrypt_ctx_drop(c);
+       keycrypt_handle_put(c->h);
+       key_put(c->key);
+       kfree(c);
+}
+
+/* The key still usable: neither revoked, invalidated nor expired */
+static int keycrypt_ctx_check(struct keycrypt_ctx *c)
+{
+       int ret = key_validate(c->key);
+
+       return ret == -EKEYREVOKED || ret == -EKEYEXPIRED ? ret :
+              ret ? -EKEYREVOKED : 0;
+}
+
+/*
+ * Under @c->h->sem: the backend to run @c on, or why there is none. A
+ * detached @c (revoked key, removed backend) gives the key's own error,
+ * else -ENODEV, and the context is not ended by it: every later call
+ * gives the same answer.
+ */
+static int keycrypt_ctx_backend(struct keycrypt_ctx *c,
+                               struct keycrypt_backend **b)
+{
+       *b = c->h->b;
+       if (*b && c->bctx)
+               return 0;
+       return keycrypt_ctx_check(c) ?: -ENODEV;
+}
+
+/* End @c after FINAL or a failure that may have changed its state */
+static long keycrypt_ctx_end(struct keycrypt_ctx *c, long ret)
+{
+       c->done = true;
+       keycrypt_ctx_drop(c);
+       return ret == -ERESTARTSYS ? -EINTR : ret;
+}
+
+/*
+ * What KEYCRYPT_IOC_INFO reports: @c's operation and accepted minimum
+ * tier, and its key's metadata
+ */
+static void keycrypt_ctx_info(const struct keycrypt_ctx *c,
+                             struct keycrypt_info *info)
+{
+       memset(info, 0, sizeof(*info));
+       info->op = c->op;
+       info->alg = c->meta.alg;
+       info->purpose = c->meta.purpose;
+       info->tier = c->meta.tier;
+       info->origin = c->meta.origin;
+       info->accepted_min_tier = c->accepted_min_tier;
+       strscpy(info->backend, c->meta.backend, sizeof(info->backend));
+}
+
+/*
+ * KEYCRYPT_IOC_INFO under @c->lock: the state checks UPDATE with no
+ * data makes, then @info.
+ */
+static long keycrypt_ctx_info_get(struct keycrypt_ctx *c,
+                                 struct keycrypt_info *info)
+{
+       struct keycrypt_backend *b;
+       long ret;
+
+       ret = mutex_lock_killable(&c->lock);
+       if (ret)
+               return ret;
+       if (c->done) {
+               ret = -EBADFD;
+               goto unlock;
+       }
+       ret = keycrypt_ctx_check(c);
+       if (!ret) {
+               down_read(&c->h->sem);
+               ret = keycrypt_ctx_backend(c, &b);
+               up_read(&c->h->sem);
+       }
+       if (!ret)
+               keycrypt_ctx_info(c, info);
+unlock:
+       mutex_unlock(&c->lock);
+       return ret;
+}
+
+static long keycrypt_ioc_update(struct keycrypt_ctx *c,
+                               struct keycrypt_update __user *uarg)
+{
+       bool hmac = c->op == KEYCRYPT_OP_MAC || c->op == KEYCRYPT_OP_VERIFY;
+       struct keycrypt_backend *b;
+       struct keycrypt_update u;
+       u8 *buf = NULL;
+       bool ran = false;
+       long ret;
+
+       if (copy_from_user(&u, uarg, sizeof(u)))
+               return -EFAULT;
+       if (u.flags || (hmac && u.out) || (!hmac && u.len && !u.out) ||
+           (!hmac && u.len % AES_BLOCK_SIZE))
+               return -EINVAL;
+       if (u.len > KEYCRYPT_UPDATE_MAX)
+               return -E2BIG;
+
+       ret = mutex_lock_killable(&c->lock);
+       if (ret)
+               return ret;
+       if (c->done) {
+               ret = -EBADFD;
+               goto unlock;
+       }
+       ret = keycrypt_ctx_check(c);
+       if (ret)
+               goto unlock;
+       if (!u.len) {
+               /* No data to run, but a detached context still answers */
+               down_read(&c->h->sem);
+               ret = keycrypt_ctx_backend(c, &b);
+               up_read(&c->h->sem);
+               goto unlock;
+       }
+       buf = kvmalloc(u.len, GFP_KERNEL_ACCOUNT);
+       if (!buf) {
+               ret = -ENOMEM;
+               goto unlock;
+       }
+       if (copy_from_user(buf, u64_to_user_ptr(u.in), u.len)) {
+               ret = -EFAULT;
+               goto free;
+       }
+       down_read(&c->h->sem);
+       ret = keycrypt_ctx_backend(c, &b);
+       ran = !ret;
+       if (!ret)
+               ret = keycrypt_ctx_ret(b->update(b, c->bctx, buf,
+                                                hmac ? NULL : buf, u.len));
+       up_read(&c->h->sem);
+       if (!ret && !hmac &&
+           copy_to_user(u64_to_user_ptr(u.out), buf, u.len))
+               ret = -EFAULT;
+       /* A failure past this point leaves the context in no known state */
+       if (ret && ran)
+               ret = keycrypt_ctx_end(c, ret);
+free:
+       kvfree_sensitive(buf, u.len);
+unlock:
+       mutex_unlock(&c->lock);
+       return ret;
+}
+
+static long keycrypt_ioc_final(struct keycrypt_ctx *c,
+                              struct keycrypt_final __user *uarg)
+{
+       bool mac = c->op == KEYCRYPT_OP_MAC;
+       bool verify = c->op == KEYCRYPT_OP_VERIFY;
+       u8 tag[KEYCRYPT_MAC_LEN] = {}, expected[KEYCRYPT_MAC_LEN];
+       struct keycrypt_backend *b;
+       struct keycrypt_final f;
+       bool by_backend;
+       size_t len = 0;
+       long ret;
+
+       if (copy_from_user(&f, uarg, sizeof(f)))
+               return -EFAULT;
+       if (f.flags || (!mac && !verify && f.out))
+               return -EINVAL;
+
+       ret = mutex_lock_killable(&c->lock);
+       if (ret)
+               return ret;
+       if (c->done) {
+               ret = -EBADFD;
+               goto unlock;
+       }
+       ret = keycrypt_ctx_check(c);
+       if (ret)
+               goto unlock;
+       if (mac && (f.len < KEYCRYPT_MAC_LEN || !f.out)) {
+               ret = -ENOSPC;          /* the context stays usable */
+               goto unlock;
+       }
+       if (verify && (f.len != KEYCRYPT_MAC_LEN || !f.out)) {
+               ret = -EINVAL;          /* the context stays usable */
+               goto unlock;
+       }
+       /* The expected tag comes in before the backend's sem is taken */
+       if (verify && copy_from_user(expected, u64_to_user_ptr(f.out),
+                                    KEYCRYPT_MAC_LEN)) {
+               ret = -EFAULT;
+               goto wipe;
+       }
+       down_read(&c->h->sem);
+       ret = keycrypt_ctx_backend(c, &b);
+       if (ret) {
+               up_read(&c->h->sem);
+               goto wipe;
+       }
+       /* A VERIFY context whose backend compares its own tag: it never
+        * exists outside the backend on this path.
+        */
+       by_backend = verify && b->verify;
+       if (by_backend)
+               ret = keycrypt_ctx_ret(b->verify(b, c->bctx, expected));
+       else
+               ret = keycrypt_ctx_ret(b->final(b, c->bctx, tag, sizeof(tag),
+                                               &len));
+       up_read(&c->h->sem);
+       ret = keycrypt_ctx_end(c, ret);
+       if (by_backend) {
+               if (!ret && put_user(0U, &uarg->len))
+                       ret = -EFAULT;
+               goto wipe;
+       }
+       if (!ret && len != (mac || verify ? KEYCRYPT_MAC_LEN : 0))
+               ret = -EIO;
+       if (!ret && verify && crypto_memneq(tag, expected, KEYCRYPT_MAC_LEN))
+               ret = -EBADMSG;         /* the computed tag never leaves */
+       if (!ret && mac && len &&
+           copy_to_user(u64_to_user_ptr(f.out), tag, len))
+               ret = -EFAULT;
+       if (!ret && put_user((u32)(verify ? 0 : len), &uarg->len))
+               ret = -EFAULT;
+wipe:
+       memzero_explicit(tag, sizeof(tag));
+       memzero_explicit(expected, sizeof(expected));
+unlock:
+       mutex_unlock(&c->lock);
+       return ret;
+}
+
+static long keycrypt_ioc_info(struct keycrypt_ctx *c,
+                             struct keycrypt_info __user *uarg)
+{
+       struct keycrypt_info info;
+       long ret;
+
+       ret = keycrypt_ctx_info_get(c, &info);
+       if (!ret && copy_to_user(uarg, &info, sizeof(info)))
+               ret = -EFAULT;
+       return ret;
+}
+
+static long keycrypt_ioctl(struct file *file, unsigned int cmd,
+                          unsigned long arg)
+{
+       struct keycrypt_ctx *c = file->private_data;
+
+       switch (cmd) {
+       case KEYCRYPT_IOC_UPDATE:
+               return keycrypt_ioc_update(c, (void __user *)arg);
+       case KEYCRYPT_IOC_FINAL:
+               return keycrypt_ioc_final(c, (void __user *)arg);
+       case KEYCRYPT_IOC_INFO:
+               return keycrypt_ioc_info(c, (void __user *)arg);
+       }
+       return -ENOTTY;
+}
+
+static int keycrypt_release(struct inode *inode, struct file *file)
+{
+       keycrypt_ctx_free(file->private_data);
+       return 0;
+}
+
+static const struct file_operations keycrypt_fops = {
+       .owner          = THIS_MODULE,
+       .unlocked_ioctl = keycrypt_ioctl,
+       .compat_ioctl   = compat_ptr_ioctl,
+       .release        = keycrypt_release,
+       .llseek         = noop_llseek,
+};
+
+/*
+ * Under @h->sem: the backend to open a context of @p on, or why there
+ * is none.
+ */
+static int keycrypt_open_backend(struct keycrypt_handle *h,
+                                const struct keycrypt_payload *p,
+                                struct keycrypt_backend **b)
+{
+       *b = h->b;
+       if (!*b)
+               return -ENODEV;
+       if (p->destroyed)
+               return -EKEYREVOKED;
+       if (!(*b)->ctx_open)
+               return -ENODEV;
+       return 0;
+}
+
+/**
+ * keyctl_crypt_open() - KEYCTL_CRYPT_OPEN
+ * @id: the key, which must be of type keycrypt and searchable
+ * @uparams: struct keycrypt_open_params
+ * @usize: its size, for extension
+ * @flags: must be zero
+ *
+ * Return: an O_RDWR | O_CLOEXEC fd bound to the key and the operation,
+ * or a negative error.
+ */
+long keyctl_crypt_open(key_serial_t id, void __user *uparams,
+                      size_t usize, unsigned long flags)
+{
+       struct keycrypt_open_params params;
+       struct keycrypt_payload *p;
+       struct keycrypt_handle *h;
+       struct keycrypt_backend *b;
+       struct keycrypt_ctx *c;
+       bool gen_iv = false;
+       key_ref_t kref;
+       struct key *key;
+       long ret;
+       int fd;
+
+       if (flags)
+               return -EINVAL;
+       if (usize > PAGE_SIZE)
+               return -E2BIG;
+       if (usize < KEYCRYPT_OPEN_PARAMS_SIZE_VER0)
+               return -EINVAL;
+       ret = copy_struct_from_user(&params, sizeof(params), uparams, usize);
+       if (ret)
+               return ret;
+       if (params.__reserved ||
+           (params.flags & ~KEYCRYPT_OPEN_CALLER_IV) ||
+           params.op < KEYCRYPT_OP_ENCRYPT || params.op > KEYCRYPT_OP_VERIFY ||
+           (params.accepted_min_tier &&
+            !keycrypt_tier_valid(params.accepted_min_tier)) ||
+           ((params.op == KEYCRYPT_OP_MAC || params.op == KEYCRYPT_OP_VERIFY) 
&&
+            memchr_inv(params.iv, 0, sizeof(params.iv))))
+               return -EINVAL;
+
+       kref = lookup_user_key(id, 0, KEY_NEED_SEARCH);
+       if (IS_ERR(kref))
+               return PTR_ERR(kref);
+       key = key_ref_to_ptr(kref);
+       if (key->type != &key_type_keycrypt) {
+               ret = -EOPNOTSUPP;
+               goto put_key;
+       }
+
+       /*
+        * key_type_keycrypt has no .update, so @p's content is immutable
+        * once instantiated: @p and @p->key.meta stay safe to read below,
+        * after key->sem is released.
+        */
+       down_read(&key->sem);
+       ret = key_validate(key);
+       p = dereference_key_locked(key);
+       if (!ret && !p)
+               ret = -ENOKEY;
+       if (!ret && !(p->key.meta.purpose & keycrypt_op_purpose[params.op]))
+               ret = -EKEYREJECTED;
+       if (!ret && p->key.meta.tier < max(params.accepted_min_tier,
+                                          keycrypt_policy_system_tier()))
+               ret = -EPERM;
+       if (!ret && (params.flags & KEYCRYPT_OPEN_CALLER_IV) &&
+           (params.op != KEYCRYPT_OP_ENCRYPT ||
+            p->key.meta.alg != KEYCRYPT_ALG_AES256_CBC))
+               ret = -EINVAL;
+       if (!ret && params.op == KEYCRYPT_OP_ENCRYPT &&
+           p->key.meta.alg == KEYCRYPT_ALG_AES256_CBC) {
+               gen_iv = !(params.flags & KEYCRYPT_OPEN_CALLER_IV);
+               if (gen_iv && memchr_inv(params.iv, 0, sizeof(params.iv)))
+                       ret = -EINVAL;
+       }
+       h = ret ? NULL : p->handle;
+       if (h)
+               refcount_inc(&h->ref);
+       up_read(&key->sem);
+       if (ret)
+               goto put_key;
+
+       if (gen_iv) {
+               ret = get_random_bytes_wait(params.iv, sizeof(params.iv));
+               if (ret)
+                       goto put_handle;
+       }
+
+       c = kzalloc_obj(*c, GFP_KERNEL_ACCOUNT);
+       if (!c) {
+               ret = -ENOMEM;
+               goto put_handle;
+       }
+       mutex_init(&c->lock);
+       INIT_LIST_HEAD(&c->node);
+       c->key = key;
+       c->h = h;
+       c->op = params.op;
+       c->meta = p->key.meta;
+       c->accepted_min_tier = params.accepted_min_tier;
+
+       down_read(&h->sem);
+       ret = keycrypt_open_backend(h, p, &b);
+       if (!ret)
+               ret = keycrypt_ctx_ret(b->ctx_open(b, &p->key, params.op,
+                                                  params.iv, &c->bctx));
+       if (!ret) {
+               mutex_lock(&h->keys_lock);
+               list_add(&c->node, &h->ctxs);
+               mutex_unlock(&h->keys_lock);
+       }
+       up_read(&h->sem);
+       if (ret) {
+               memzero_explicit(params.iv, sizeof(params.iv));
+               kfree(c);
+               goto put_handle;
+       }
+
+       /* The write-back happens before the fd exists: no fd on EFAULT */
+       if (gen_iv &&
+           copy_to_user(((struct keycrypt_open_params __user *)uparams)->iv,
+                        params.iv, sizeof(params.iv))) {
+               memzero_explicit(params.iv, sizeof(params.iv));
+               keycrypt_ctx_free(c);
+               return -EFAULT;
+       }
+       memzero_explicit(params.iv, sizeof(params.iv));
+
+       fd = anon_inode_getfd("[keycrypt]", &keycrypt_fops, c,
+                             O_RDWR | O_CLOEXEC);
+       if (fd < 0)
+               keycrypt_ctx_free(c);
+       return fd;
+
+put_handle:
+       keycrypt_handle_put(h);
+put_key:
+       key_put(key);
+       return ret;
+}
diff --git a/security/keys/keycrypt/keycrypt.h 
b/security/keys/keycrypt/keycrypt.h
new file mode 100644
index 000000000000..5a41a68c48fa
--- /dev/null
+++ b/security/keys/keycrypt/keycrypt.h
@@ -0,0 +1,173 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * keycrypt - core-private definitions
+ *
+ * Copyright (C) 2026 Rodolfo Giometti <[email protected]>
+ */
+
+#ifndef _SECURITY_KEYS_KEYCRYPT_H
+#define _SECURITY_KEYS_KEYCRYPT_H
+
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/refcount.h>
+#include <linux/rwsem.h>
+#include <keys/keycrypt.h>
+
+#define KEYCRYPT_BLOB_MAX      (KEYCRYPT_HEADER_MAX + 4 + \
+                                KEYCRYPT_BACKEND_DATA_MAX)
+#define KEYCRYPT_INPUT_MAX     (2 * KEYCRYPT_BLOB_MAX + 256)
+
+#define KEYCRYPT_CMD_NEW       1
+#define KEYCRYPT_CMD_LOAD      2
+#define KEYCRYPT_CMD_IMPORT    3
+
+/**
+ * struct keycrypt_handle - the core's record of a registered backend
+ * @list: in the registry, under keycrypt_lock; unlinked by unregister
+ * @ref: one for the registry, one per key
+ * @sem: held for reading around backend calls, for writing by unregister
+ *     and revoke
+ * @b: the backend, NULL once unregistered
+ * @keys_lock: guards @keys and @ctxs
+ * @keys: the payloads of the backend's keys
+ * @ctxs: open contexts, under @keys_lock
+ * @tier: the backend's tier
+ * @name: the backend's name
+ */
+struct keycrypt_handle {
+       struct list_head        list;
+       refcount_t              ref;
+       struct rw_semaphore     sem;
+       struct keycrypt_backend *b;
+       struct mutex            keys_lock;      /* guards @keys and @ctxs */
+       struct list_head        keys;
+       struct list_head        ctxs;
+       u8                      tier;
+       char                    name[KEYCRYPT_BACKEND_NAME_MAX + 1];
+};
+
+/**
+ * struct keycrypt_payload - the payload of a keycrypt key
+ * @handle: the backend's handle, NULL until the backend accepted the key
+ * @owner: the backend's module, pinned while the key exists
+ * @node: in @handle->keys
+ * @key: what the backend sees; its hdr and data point into @blob
+ * @destroyed: @key's backend state released; set once, under @handle->sem
+ *     held for writing, or by the payload's own free
+ * @blob_len: bytes in @blob
+ * @blob: header, le32 length of the backend data, backend data
+ */
+struct keycrypt_payload {
+       struct keycrypt_handle  *handle;
+       struct module           *owner;
+       struct list_head        node;
+       struct keycrypt_key     key;
+       bool                    destroyed;
+       u32                     blob_len;
+       u8                      blob[];
+};
+
+/**
+ * struct keycrypt_req - a parsed add_key() payload
+ * @cmd: KEYCRYPT_CMD_*
+ * @alg: KEYCRYPT_ALG_* (new, import)
+ * @purpose: KEYCRYPT_PURPOSE_* mask (new, import)
+ * @want_purpose: "purpose=" of load, or 0
+ * @tier: "tier=" of new and import, or 0
+ * @min_tier: "min-tier=" of new and import, or 0
+ * @accepted_min_tier: "accepted-min-tier=" of load, or 0
+ * @backend: "backend=" of new and import, or empty
+ * @hex: the blob (load) or the key (import), hex encoded
+ * @opts: buffer, given by the caller, receiving the options for the
+ *     backend, space separated
+ * @opts_size: size of @opts
+ */
+struct keycrypt_req {
+       int             cmd;
+       u8              alg;
+       u16             purpose;
+       u16             want_purpose;
+       u8              tier;
+       u8              min_tier;
+       u8              accepted_min_tier;
+       char            backend[KEYCRYPT_BACKEND_NAME_MAX + 1];
+       const char      *hex;
+       char            *opts;
+       size_t          opts_size;
+};
+
+/**
+ * struct keycrypt_ctx - an open operation context
+ * @lock: serialises the calls on the fd
+ * @key: the key, referenced
+ * @h: its backend's handle, referenced
+ * @node: in @h->ctxs, under @h->keys_lock
+ * @bctx: the backend's state; NULL once detached (revoked, unregistered,
+ *     or ended by FINAL or a failure)
+ * @op: KEYCRYPT_OP_*
+ * @meta: @key's metadata, copied at open
+ * @accepted_min_tier: the caller's KEYCRYPT_TIER_* at open, or 0
+ * @done: ended by FINAL or by a failure once the backend ran; every later
+ *     call gives -EBADFD
+ */
+struct keycrypt_ctx {
+       struct mutex            lock;   /* serialises the calls on the fd */
+       struct key              *key;
+       struct keycrypt_handle  *h;
+       struct list_head        node;
+       void                    *bctx;
+       u32                     op;
+       struct keycrypt_meta    meta;
+       u8                      accepted_min_tier;
+       bool                    done;
+};
+
+/* The key length each algorithm takes; false for an unknown alg */
+static inline bool keycrypt_key_len_valid(u8 alg, size_t len)
+{
+       switch (alg) {
+       case KEYCRYPT_ALG_AES256_CBC:
+               return len == 32;
+       case KEYCRYPT_ALG_HMAC_SHA256:
+               return len >= 1 && len <= 64;
+       }
+       return false;
+}
+
+/* The tiers a key may have, and a tier option may name */
+bool keycrypt_tier_valid(u32 tier);
+
+/* The system tier at boot (Kconfig); it can only be raised */
+#if IS_ENABLED(CONFIG_KEYCRYPT_SYSTEM_TIER_HSM)
+#define KEYCRYPT_BOOT_SYSTEM_TIER      KEYCRYPT_TIER_HSM
+#elif IS_ENABLED(CONFIG_KEYCRYPT_SYSTEM_TIER_TEE)
+#define KEYCRYPT_BOOT_SYSTEM_TIER      KEYCRYPT_TIER_TEE
+#else
+#define KEYCRYPT_BOOT_SYSTEM_TIER      KEYCRYPT_TIER_KERNEL
+#endif
+
+/**
+ * struct keycrypt_policy - system-wide limits, one-way until reboot
+ * @lock: serialises changes
+ * @system_tier: KEYCRYPT_TIER_*: the lowest tier a key may be used at;
+ *     can only be raised
+ * @import: import allowed; can only be turned off
+ */
+struct keycrypt_policy {
+       struct mutex    lock;   /* serialises changes */
+       u8              system_tier;
+       bool            import;
+};
+
+extern struct keycrypt_policy keycrypt_policy;
+u8 keycrypt_policy_system_tier(void);
+bool keycrypt_policy_import(void);
+
+extern struct key_type key_type_keycrypt;
+int keycrypt_backend_ret(int ret);
+void keycrypt_handle_put(struct keycrypt_handle *h);
+void keycrypt_ctx_detach(struct keycrypt_backend *b, struct keycrypt_ctx *c);
+void keycrypt_ctx_revoke(struct keycrypt_handle *h, struct key *key);
+
+#endif /* _SECURITY_KEYS_KEYCRYPT_H */
diff --git a/security/keys/keyctl.c b/security/keys/keyctl.c
index d6b10fd67627..d74708b832ea 100644
--- a/security/keys/keyctl.c
+++ b/security/keys/keyctl.c
@@ -2031,6 +2031,11 @@ SYSCALL_DEFINE5(keyctl, int, option, unsigned long, 
arg2, unsigned long, arg3,
        case KEYCTL_WATCH_KEY:
                return keyctl_watch_key((key_serial_t)arg2, (int)arg3, 
(int)arg4);
 
+       case KEYCTL_CRYPT_OPEN:
+               return keyctl_crypt_open((key_serial_t)arg2,
+                                        (void __user *)arg3,
+                                        (size_t)arg4, arg5);
+
        default:
                return -EOPNOTSUPP;
        }
-- 
2.43.0


Reply via email to