From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=62.149.156.87 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1795010682; b=u+GG1aePTRZlC094YTAsEgary9fDtE0KEst2lLeeaO7vB8JrJ66TENFsfgsMsEhBhzwB VAjPyMWdE8TPB5PHY4gKH3WGHlB46lQ3is6a3vdWRvF/PLWdscWJPhbsrEKo3XM/YiBTC cV5L06DSI1ISH71QTQdW7z+/6eR8X0ykzvbC6MzKBggX02Gq9rcQ4OGMP0H1w3KlcseIm uLQKXAZjy8AdTtBjdPBcYjkuuAbg9aFouILYv4HPuXfBUegobVxhssmDPZ5k4QU0mokeQ Xpafz5X2MsS4c5C60wgdML7mpzrI9gLp0SDWs/RgIOHECgYWF3eGZBv89yF6zXnhvcQ== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795010682; h=DMARC-Filter:Received:DKIM-Signature:From:To:Cc:Subject:Date: Message-ID:X-Mailer:In-Reply-To:References:MIME-Version: Content-Transfer-Encoding:X-CMAE-Envelope; bh=zytyVC19xEXbb5X63vY6M3SRR7AUP2azHT3o3wfjjD4=; b=r03z2aqtRA65NjdmWjcnukn5SFEpmQOZSlfuliT7yVwelab8/kdc1JlJPlDk0WkXb61F GilAVt3oJ8jalAiGzKrLlWNEiCabz4ZUnexox0vhU/KvgsM7tpGao7qKWq+2Uk6M7xD3b BLVargfsSIhbSkiAZxDFzmYGODH972zjoRk6+TMK5edC3lm1Ywr16tEEiNyLFCZCDN2Oo PVpXXTbdG6Fyt9gj/0d5EUa5EVcYyLU0Cb/GgN9xtq1x0m11qW+6CSsQ18DjKm9d2Bbn0 SyICjIWkmmd81XKzvOn8c6dIS8zf8X5P9ITccMy5H9X8WPRvlzoi55KsJ/pilWwXl9g== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=enneenne.com; spf=pass smtp.mailfrom=enneenne.com; dkim=pass header.d=aruba.it header.i=@aruba.it header.a=rsa-sha256 header.s=a1 header.b=WKxbXt7k; arc=none smtp.remote-ip=62.149.156.87 Received: from smtpcmd0987.aruba.it (smtpcmd0987.aruba.it [62.149.156.87]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C1603606A33A for ; Wed, 18 Nov 2026 14:04:37 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org C1603606A33A Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=enneenne.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=enneenne.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=aruba.it header.i=@aruba.it header.a=rsa-sha256 header.s=a1 header.b=WKxbXt7k Received: from polimar.tail4f75e6.ts.net ([101.57.122.26]) by Aruba SMTP with ESMTPSA id TgGvxLK1X6q8sTgGzxc6MR; Wed, 18 Nov 2026 15:04:30 +0100 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=aruba.it; s=a1; t=1795010670; bh=n41lTxgDIMigqaCL6ajMk5RYGrDT0zdJ1a4SEDn8Hn4=; h=From:To:Subject:Date:MIME-Version; b=WKxbXt7kT0sdQ5Kev/+snXACrXL7UM1hcJhXnQ0G19zM6vL0j19iwZfk9Qsks33Wa ajNkdLjUocZXethtYndsnkfqaLUkTwCkOGFevnQCtPMNkMkNhpZSD6gKjYYkpdJT0s /L9WNUwjaqawDQsTo28yGglUGzmS1ltDkxEEnm8cgHtgd1HvP9N/N52MhEGk7txSwx Qb0ItuETz7q7xG416M3xXnsLb2WYUrhIzCNarh2R/y702imQ4iZuP1HcUPrZPyFJEJ W11taG03K+Zh1F+vcP8vz1dD/ISkEQLCZQoCT7YDe4Fa2GOZzqQvgx7m3fhziLtUvE F4y7aORzJuuvA== From: Rodolfo Giometti To: David Howells , Jarkko Sakkinen , keyrings@vger.kernel.org Cc: Herbert Xu , "David S. Miller" , Jens Wiklander , Sumit Garg , op-tee@lists.trustedfirmware.org, =?UTF-8?q?Horia=20Geant=C4=83?= , Pankaj Gupta , Sahil Malhotra , Ahmad Fatoum , Richard Weinberger , "Christophe Leroy (CS GROUP)" , Eric Biggers , Demi Marie Obenour , Arnd Bergmann , Paul Moore , James Morris , "Serge E. Hallyn" , Jonathan Corbet , Shuah Khan , Randy Dunlap , 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 Subject: [RFC PATCH 1/9] KEYS: keycrypt: Add a key type for keys user space never reads Date: Wed, 18 Nov 2026 15:04:13 +0100 Message-ID: <20261118140421.584086-2-giometti@enneenne.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20261118140421.584086-1-giometti@enneenne.com> References: <20261118140421.584086-1-giometti@enneenne.com> X-Mailing-List: linux-doc@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-CMAE-Envelope: MS4xfP3GH+/uUH2UT8xMvG9D4FaNvSpSliR0tTjVUWsuRp2/IOriQDotlmu0kb3Bvcv48aoM5XNmWbhv5eiS7QNJbgeBC1jsSjfOF972Rnh0emTdPjKGem6H R8FQM5ApEvDUk+7C5B64URlE/DqsWbFPmIqF5Fdxjbuw5qXpIO8d3te0cEC82Z1yxBQsfy5fV3Q6vZ1LuvDllWjcXQWhDr7/HbtU7r6PNWGUC6idVx8Dr8+B ek4wY1yZBCSekXremPsy96JR7VaG9YbC7dlZs/oF6FLaX56+khmMFDlKpg5Dga4RtCmlhP/PTf3/Dh/xG0Z35IxWGkvCS6mi3AQfMrTerV4gSjhBfTQ8TQhO 2WtVsUgvTKAdiS2UhdVIk71THz3tgRxdeiBji8ZF+HADmbWgIlux4FlE4A0p3VP28f3gPJjwZKDH6AglEq+tcr1rjRLY8s7zrvU3ThHx7VMVVqpygaf93J27 DHVEmdvKZFfR2UpWKSpSpKe8bJ0gn5UBlCLF0U9qDWYm+OsTcJC1+LnMhIjs4V4ikBIZNYQ72dmcSA3wyxBIE0HTPEzGG5/FK79bEa+OjwBYPRNnZMFu4/jE 8fLscBn43xcxUZDE5f739I9U6VsNnUIH18fH8PjS9D9PsDJMhGMIuXaIiTxfCA1eB5mKHBc0ZnDALP0lYEcdczQp4+tzuYYNQ5Dm+6QH5rRsXS2mo/04EzVe gOWbCEMppMR8Ix+CM/H9ZCn3Merx9nyppgAhPDvrxQg21bU2Slt3lq4OPuwCaUo4PM1BGE3mSkSH/K1Lh7n2baw0oAovFNLJASml8hcwqvwIut+vbNsDev+/ jL4TwCncokB9Gi9URV3sZeunfcG9elxQWWwLF70sRfu/Lj5CRo/LRnLLovR6bdbfJLbQL9PSC4rTIB9ezDgA8pCsliQo+8sfWszS7g+kZLsqcJe/pCzk3G2a K+aXWYYMBQ0+ZNodOykTnAu3U4Hpwf+A2Zhq0OsFvpNa5DfzMmhakS1mds1nPPfv5ZvQqawz4umbE/HXrLCnbCHipO7LH80m7k96Pvpd8GYdU5c+qkfL6OQj fBCugevbR4dYV71GmnWwMQf65uCPFfgEkHD8W5tyK0vJk30l/gaBt/FPPDGig/O2ukfHCRY0tThWdOkh7mGihZ6qm0bRs1fluXnNy3LNQBVXy/6c/Tec1ozG NUtfvoTF17PzVAAZusBifuJoXObZh4EK1MP30GWBGgaUpFqcU8vImlEjsHJ2AZ7eVxR1conCt1qT4W3JkVapXZnACuU4vDw/6BLTMqZ/9OLmP+rDNjRBJRSv hk8hlS8qrmlHW4pWqVe6at3+Hlu3MLpacBiP3W/Elb7Irg4wAAw= 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 --- .../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: + 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 0xBA 00-0F uapi/linux/liveupdate.h Pasha Tatashin +0xBB 00-0F uapi/linux/keycrypt.h keycrypt + 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 + */ + +#ifndef _KEYS_KEYCRYPT_H +#define _KEYS_KEYCRYPT_H + +#include +#include +#include + +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="); 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 + */ + +#ifndef _UAPI_LINUX_KEYCRYPT_H +#define _UAPI_LINUX_KEYCRYPT_H + +#include +#include + +/* 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 + */ + +#define pr_fmt(fmt) "keycrypt: " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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 [,...] [