Hi Rodolfo,
thanks for the RFC and bringing this up. Please see my comments below.
On 26-11-18 15:04, Rodolfo Giometti wrote:
> This RFC proposes a key type, "keycrypt", whose material user space can
Albeit I'm not against a new key-type we already have plenty types.
Furthermore the keyctl API is very open, lacks a common API. E.g. for the
'trusted-key' keytype userspace needs to know the actual used backend
because each backend handles it differently.
Therefore I wouldn't add further keytypes till we have a common API
which the userspace can rely on.
> use for symmetric operations but never read: AES-256-CBC, HMAC-SHA256
> and an authenticated AES-256-GCM stream, through a file descriptor that
> KEYCTL_CRYPT_OPEN returns for one key and one operation. The key is held
> by a backend: the kernel itself (sealed under a trusted key), an OP-TEE
> trusted application, or, as a proposal only, the CAAM. I am asking
> whether this is a direction the keyrings, crypto and TEE maintainers
> would take, before polishing it further.
So it's not a new keytype but a new mechanism to handle trusted-keys
from userspace?
> Patch 9, the authenticated stream, is a proposal on its own and not
> needed by the rest of the series: it is a construction of keycrypt's
> own, and patches 1-8 do not depend on it, so it can be discussed, or
> left out, apart from them. No user-space consumer uses the stream or
> HMAC-SHA256 yet: craf (below) uses CBC only. If this direction is found
> acceptable, one of the next steps is to bring craf's keycrypt backend
> into craf's main line, with the stream and HMAC-SHA256, as long as
> doing so does not stand in the way of this RFC or of the series I hope
> will follow it.
>
> The problem
> -----------
>
> An embedded product that encrypts its own data (a root filesystem
> archive, configuration backups, logs) needs a key that does not sit in
> the root filesystem and that a compromised user space cannot copy. Today
^
What exactly do you mean by copy?
If you're using the standard LUKS2 scheme, the (volume)key never sits
inside encrypted device. The key is part of the LUKS2 header. Maybe I
didn't got your use-case, can you please elaborate a bit more?
> user space either reads the key (a user or logon key handed to AF_ALG)
> or cannot use it at all (a trusted key serves kernel consumers only).
> AF_ALG, the one interface that let user space drive a key the kernel
> held, has moved away from that use: v7.2 dropped off-CPU cryptography
> from it (7524070f26d8, "crypto: af_alg - Drop support for off-CPU
> cryptography"), whose message says "If using an off-CPU accelerator
> really does turn out to be a win, a new API should be developed that is
> actually a good fit for it", and v7.3 restricted it to allowlisted
> generic algorithms by default (2f204fe718f5, the af_alg_restrict
> sysctl). One exception was let back in, cbc(paes) with a CAAM blob in
> place of the key, because "this crypto operation cannot be implemented
> in a userspace library" (285d8204638c, v7.2), for privileged users only
> (d9506e82ced5, v7.3): the need is acknowledged, for one driver and
> one mode. keycrypt is meant to be the API that 7524070f26d8 asks for,
> for keys that stay in a TEE or in hardware, whatever the backend.
Above you mentioned trusted-keys, but trusted-keys don't let the key
stay inside the TEE. Albeit the key is only reachable kernel (EL1) it is
always reachable from normal world. So a kernel CVE could leak the key
as well. This is different compared to protected keys like
p(rotected)aes. Here the keys always stay within firmware/secure-world.
I didn't get your problem from your above description, sorry and
therefore I'm asking.
Do you want to use trusted-keys for partition (rootfs, data, ...)
encryption? In such case I've developed another idea which I'm about to
post as RFC.
> The interface
> -------------
>
> 1. A key type, "keycrypt", created with add_key() from "new <alg>
> <purposes> [tier=|min-tier=] [backend=]", "load <blob>
> [accepted-min-tier=] [purpose=]" or, when allowed, "import <alg>
> <purposes> [tier=|min-tier=] [backend=] <hex>". User space states the
This is exactly what I meant at the begining. I'm not a maintainer, but
this string parsing "API" is very error-prone. Furthermore, how can a
userspace enum available backends? Instead of try and error I would like
to see a query/enum phase and later on userspace can decide which
backend and tier to use.
> protection a key needs, as a tier, and the kernel chooses the backend
> that provides it, unless backend= names one. backend= is a constraint
> added to the tier, never one in its place: a named backend that does
> not meet tier= or min-tier= gives ENODEV, not a weaker key. It is for
> a system with more than one backend, an i.MX8 with both the CAAM and
> OP-TEE say, where a program must choose which mechanism holds a key
> (the cost of each call, what the key is bound to) and not only how
> well; the name chooses among mechanisms that meet the tier asked for,
> it never lowers a tier asked for (without one, it takes that backend
> at the tier it declares, so a program that needs a tier states it).
> Its payload read back is a blob that only that backend can open; the
> material itself never reaches user space.
> 2. Each key is bound, when it is made, to one algorithm and to the
> purposes it may serve, checked at every open:
> a. encrypt and decrypt, for aes256-cbc and aes256-gcm-stream keys:
> a key that may only encrypt lets a device write data it cannot
> read back, a key that may only decrypt the reverse;
> b. mac and verify, for hmac-sha256 keys: "mac" computes a tag over
> data, "verify" only checks a tag given by the caller, so a
> component holding a verify-only key can authenticate data (a
> configuration, an update) but cannot produce a tag that would
> pass. VERIFY takes the expected tag at FINAL and answers 0 or
> EBADMSG; the tag it computed never leaves the backend. For
> example, a server authenticates the commands it sends to a fleet
> of devices with HMAC-SHA256, and every device holds the same key,
> imported at the factory as verify-only. With a plain HMAC key,
> root on one device could extract it and forge commands for the
> whole fleet; with a verify-only keycrypt key held by a tee or hsm
> backend, a compromised device can still check commands but can
> neither read the key nor compute a tag that passes. It comes
> close to what a signature gives (everyone verifies, only the
> server signs), with a MAC, as long as no device's TEE or HSM is
> broken: the key is the fleet's, so the device that breaks forges
> for all of it, which a signature would not allow.
> 3. KEYCTL_CRYPT_OPEN (keyctl 33) opens an operation context on a key and
> returns an fd; ioctls on it: KEYCRYPT_IOC_UPDATE, KEYCRYPT_IOC_FINAL,
> KEYCRYPT_IOC_SEGMENT (the GCM stream, patch 9) and KEYCRYPT_IOC_INFO,
> which tells a program holding only the fd (passed by SCM_RIGHTS, say)
> the operation, the minimum tier it was opened with, and the
> algorithm, purposes, tier, origin and backend of the key it is using.
> Search permission on the key is the right to open it; the caller may
> name the lowest tier it accepts (accepted_min_tier), and a key below
> it is refused.
> 4. Policies: kernel.keys.keycrypt_system_tier and
> kernel.keys.keycrypt_import (also the boot parameters
> keycrypt.system_tier= and keycrypt.import=), one-way, so that a
> system can refuse the use of low-tier keys or clear-key import for
> good. The system tier is a floor on use only: keys below it can
> still be made and loaded, but KEYCTL_CRYPT_OPEN refuses them. Its
> starting value is chosen at build time
> (CONFIG_KEYCRYPT_SYSTEM_TIER_*), so a signed kernel image carries a
> floor its command line cannot lower; likewise, a kernel built
> without CONFIG_KEYCRYPT_IMPORT refuses import whatever its command
> line or sysctl say.
> 5. EOPNOTSUPP from KEYCTL_CRYPT_OPEN means "not a keycrypt key", or a
> kernel without keycrypt, so a library may fall back to another
> interface on it; ENODEV means no backend can run the key.
>
> Tiers and what a compromised kernel can do
> ------------------------------------------
>
> Each backend declares a tier, and the open path checks it against the
> system tier and the caller's accepted minimum:
>
> tier key in clear purpose enforced by who may use the key
> in the kernel
> kernel yes the kernel the kernel
These are basically the trusted-key purpose.
> engine no the kernel the kernel
> tee no the TA the kernel
> hsm no the HSM the kernel
These are protected keys which we have already (see S390, CAAM, DCP,
Zynqmp, ...).
I don't see what you want to solve with your approach. Do you want to
have a common interface for generating/loading protected keys?
That beeing said, loading protected keys can already be done by just
specifying the correct key-cipher. Generating the key is platform
specific and would need a common API.
Thanks for sharing your ideas :)
Regards,
Marco
> The last column is the limit of the mechanism: a compromised kernel can
> use a tee or hsm key for the purposes it already has, but cannot extract
> it or change its purpose. Documentation/security/keys/keycrypt.rst,
> "Backend requirements", is the contract a tee or hsm backend must meet.
>
> 1. kernel: the keys are in clear in kernel memory while loaded. It is
> there so that the same interface works on a system with no TEE and
> no suitable hardware, where it still keeps the key out of user space
> and out of the root filesystem; its one backend, sw, is off by
> default (CONFIG_KEYCRYPT_SW), and a system that has one of the
> other tiers should use it, engine at least, and raise the system
> tier accordingly. Raising it stops the use of kernel-tier keys, not
> their presence: one created or loaded below it is in clear all the
> same, as its trusted master is, so a system that must have none
> builds without CONFIG_KEYCRYPT_SW.
> 2. engine: a crypto engine the kernel drives keeps the key, never in
> clear in the kernel, but its use is decided by the kernel only. It
> comes in patch 6, on its own, so that patches 1-5 stand without a
> tier no backend of theirs declares. The CAAM backend of this series
> is an engine, since the CAAM does not check what a key is used for;
> an ELE backend (below) would start as an engine too, and could move
> to hsm once the firmware is confirmed to enforce a key's purpose. If
> more such shades appear, a separate property may fit better than
> more tiers, and I would welcome an opinion.
> 3. tee: the OP-TEE backend; the TA re-checks every operation against
> the purposes it bound when the key was sealed.
> 4. hsm: as tee, in dedicated hardware apart from the CPU running the
> kernel (a secure element, a security core of its own such as NXP's
> EdgeLock Enclave, a crypto engine with its own policy), the place of
> Android KeyMint's StrongBox; no backend in this series.
>
> The backends
> ------------
>
> 1. sw, of the kernel tier (no name is both a tier's and a backend's):
> keys sealed with AES-256-GCM under a key derived with HMAC-SHA256
> from a trusted key (any trusted-key source); HKDF-derived stream
> subkeys; lib/crypto AES. Where the trusted key
> comes from a TPM, the TPM only unseals that master when a key is
> loaded; the data itself is ciphered on the CPU, never by the TPM.
> 2. OP-TEE: a trusted application, an early TA, REE kernel login only;
> it derives its sealing key from OP-TEE's hardware-unique-key
> service. The TA is written (ta/keycrypt, one patch to optee_os) and
> is the one that ran on the hardware below, but I have not proposed
> it to OP-TEE yet: I would first like to know whether this direction
> can go on. I can publish it for anyone who wants to try it and is
> willing to support the work.
> 3. CAAM: patches 7 and 8, a proposal and not to be applied as they
> are.
> They are based on Richard Weinberger's "crypto: caam" series v1 (see
> "Base and prerequisites") and never ran on a CAAM. Questions for the
> CAAM maintainers:
> a. is an internal cbc(paes) taking the caller's key modifier an
> acceptable form;
> b. can a job generate a key in the CAAM and keep it black without it
> crossing kernel memory;
> c. can the use of a key be checked by something a compromised kernel
> does not drive: trusted descriptors, which would let the CAAM
> itself enforce a key's purpose and make the backend hsm, or a job
> ring owned by the secure world, which would make it tee;
> d. could cbc(paes) take CCM black keys, which are authenticated where
> ECB ones are not, once the driver handles their extra length
> (Weinberger's series refuses them, so the backend uses ECB).
> 4. ELE (i.MX9), not in this series: this is an RFC, and I am not an
> expert of the enclave, so I would rather know first what NXP thinks
> of it, and whether they would be willing to propose an ELE backend
> themselves, as an engine or, better, as an hsm. As far as I can see,
> the se_if driver in linux-next gives user space a misc device with a
> generic send-and-receive ioctl for the enclave's messages, and offers
> nothing to other kernel code. A per-operation in-kernel API exported
> by that driver (open a key store reserved to the kernel, generate a
> key, import a wrapped one, read a key's attributes, delete it,
> AES-CBC and MAC in one call) would let a keycrypt backend use the
> enclave. Questions for NXP:
> a. does the firmware enforce a key's key_usage and permitted_algo on
> every operation, min_mac_length when verifying, and never release
> a generated key in clear (yes to all three would make the backend
> hsm rather than engine);
> b. could a key be exported wrapped under a device-unique key and
> imported again, so that a keycrypt blob holds the key itself
> rather than a reference to the enclave's key store;
> c. is the key that wraps an imported key unique per device;
> d. the user-space library has a streaming MAC (hsm_mac() with its
> INIT, UPDATE_DATA and FINALIZE flags): would the firmware offer
> it to the kernel for a key in its key store;
> e. can a key_id be reused after a key is deleted (the library's
> documentation does not say);
> f. would a per-operation API of this kind answer the objection Arnd
> Bergmann raised to the generic passthrough
> (<[email protected]>).
>
> Base and prerequisites
> ----------------------
>
> The series is based on mainline v7.4-rc2-92 (067c5c24cef2). Patches
> 1-6, and patch 9 on top of them, apply on it alone. Patches 7 and 8, the
> CAAM proposal, need Richard
> Weinberger's "crypto: caam" series v1
> (<[email protected]>, three patches, listed as
> prerequisites below) applied first, for example with:
>
> b4 am -o - [email protected] | git am
>
> Testing
> -------
>
> The series comes without its tests. There are KUnit suites for the
> core and the sw, OP-TEE and CAAM backends, and a kselftest for the user
> ABI, with a case for every reachable row of keycrypt.rst's error
> tables; together they are larger than the code they test, so I am
> keeping them for the non-RFC series, once the direction is agreed. The
> results below that name them come from the series with the tests in it.
> Taking them out removed only the tests and the hooks that let them
> reach the code's internals (static functions made visible and exported
> to KUnit modules): with CONFIG_KUNIT off, the posted patches build for
> arm64 to the same instructions as that series.
>
> On that base, with Weinberger's three patches applied: built for arm64
> with W=1 (security/keys/keycrypt/ and drivers/crypto/caam/, no
> warning), and, with the tests on top, the KUnit suites pass on UML
> but for the one case that needs the system tier above kernel (by
> Kconfig or boot parameter). Patches 1-6 and 9 alone, on the base without
> Weinberger's patches: the same build of security/keys/keycrypt/, no
> warning.
> The runs below were made on that series at v7.3 on QEMU, and, without
> the CAAM code, backported to NXP's 6.18, on QEMU and on hardware:
>
> 1. QEMU (qemuarm64-secureboot, OP-TEE 4.9.0, an fTPM as the source of
> the trusted master): the KUnit suites and the kselftest passed on
> the sw and OP-TEE backends, a case skipped only where its backend
> was absent (the CAAM) or where it needs a one-way policy setting;
> the TA's unbind and bind; persistence of a blob across a restart.
> QEMU proves function, not secrecy: its hardware unique key is a stub.
> 2. Hardware: the series, backported to NXP's linux-imx lf-6.18.2-1.0.0
> (six upstream prerequisites; the two CAAM patches left out), with the
> TA built as an early TA into NXP's imx-optee-os 4.8.0, ran on an
> i.MX93 board with secure boot closed (AHAB), where OP-TEE derives the
> key that seals the TA's key blobs from the EdgeLock Enclave's
> hardware unique key. The KUnit suites and the kselftest passed on
> the OP-TEE backend, a case skipped only where its backend was absent
> (sw, which 6.18 cannot build for lack of the library AES it needs,
> and the CAAM, left out) or where it needs a one-way policy setting.
> A key generated in OP-TEE and kept as its blob
> was loaded back after a reboot and after a full power-off, and
> decrypted a file encrypted before them. The same AES-256-CBC key and
> IV through AF_ALG (cbc-aes-ce), through keycrypt and through openssl
> gave identical ciphertexts.
> 3. Cost on that board (Cortex-A55), AES-256-CBC, per call on an open
> context: keycrypt with the OP-TEE backend 59-62us up to 256 bytes,
> ~106us at 4KiB, 880-930us at 64KiB (67-71MiB/s); AF_ALG cbc-aes-ce
> 6-7, 12-14 and 110-138us (454-570MiB/s). Opening a context costs
> ~500us, against ~9us for an AF_ALG accept on a keyed socket (~25us
> for the whole AF_ALG setup). OP-TEE's own benchmark (xtest
> --aes-perf, from user space through libteec) on the same board gives
> ~64us per call plus ~1.5ns per byte. keycrypt's fixed cost matches
> that round trip to the secure world; its remaining ~11ns per byte is
> spent in this prototype's own data path (buffer allocation and
> copies between user space, kernel, shared memory and the TA); which
> part dominates is not yet measured, and it is to be reduced.
>
> A user-space consumer exists: craf, the archive tool of crypto-afalg,
> has a keycrypt backend on the keycrypt branch of
> https://github.com/giometti/crypto-afalg (tag keycrypt-board-5 is the
> version that ran on the hardware above). Its enc command, an openssl
> enc that takes its key from the keyring, shows what a keycrypt key
> carries. A key made once as
>
> k=$(keyctl add keycrypt demo \
> "new aes256-cbc encrypt,decrypt min-tier=tee" @u)
>
> is bound there to AES-256-CBC, to encrypting and decrypting, and to a
> backend of tier tee at least, chosen by the kernel; so
>
> craf enc -enc-key $k -iv <hex> < plain > cipher
> craf enc -d -enc-key $k -iv <hex> < cipher > plain
>
> need nothing else: the open takes no algorithm and no backend, the key
> brings them, and its tier is enforced by the kernel against
> -enc-min-tier or the system's tier. Any other key goes to AF_ALG, and
> the command line must name the cipher. On the board, craf enc with an
> imported keycrypt key and openssl enc with the same key bytes and IV
> each decrypted what the other encrypted.
>
> While testing the user-space side of this series, craf's test suite hit
> the KEYCTL_PKEY_VERIFY regression of cb481e59ea6c, which lets a short
> RSA signature verify: it is fixed by Florian Bauckholt's patch [1], and
> the reproducer was reported in [2].
>
> [1]
> https://lore.kernel.org/keyrings/[email protected]/
> [2]
> https://lore.kernel.org/all/[email protected]/
>
> Why not AF_ALG or KEYCTL_PKEY_*
> -------------------------------
>
> They are the two existing interfaces through which user space uses a
> key it does not read, so they are the first alternatives a reviewer
> will name; keycrypt.rst has a section on them.
>
> 1. AF_ALG takes a trusted key by serial (ALG_SET_KEY_BY_KEY_SERIAL),
> but copies its payload into the socket, ties it to no algorithm and
> no purpose, and runs it on whatever implementation the socket is
> bound to, since v7.2 only on the CPU but for cbc(paes); extending it
> would mean adding purposes, tiers and off-CPU backends to what it
> has just removed.
> 2. KEYCTL_PKEY_* already lets user space use a key without reading it,
> but for asymmetric keys, one operation per call; a symmetric mode
> needs state across calls (the CBC chain, the stream's segments),
> which an fd holds naturally.
>
> Whether one of them should be extended instead is the first question I
> would like answered.
>
> Known limits
> ------------
>
> Some are limits of the design, kept on purpose:
>
> 1. Only the sw backend is self-contained in the tree; every guarantee
> against a compromised kernel is a requirement on the other backends,
> which "Backend requirements" in keycrypt.rst sets out.
> 2. Kernel-tier keys are in clear in kernel memory while loaded: that
> tier is there for systems with nothing better, and a system that has
> more can refuse it (above).
> 3. The tier is declared by the backend, not proven: the kernel cannot
> check what a TEE or a piece of hardware does, so it records and
> enforces what the backend declares.
> 4. A blob is a bearer credential, and a process that possesses a key
> can read its blob: what binds the key is the backend's secret,
> unique to the device, and the purposes sealed with it, not the blob.
> 5. CBC is unauthenticated and is a raw AES oracle for its holder: it is
> there for the formats that need it, and the GCM stream is the
> authenticated choice. The stream is not key-committing, which a
> format trying several keys must handle (keycrypt.rst says how), and
> is bounded at 2^32-1 segments, 256TiB at 64KiB each.
>
> The others I plan to address if this direction is taken:
>
> 6. Checks happen at open only, so an open context survives a raised
> policy or removed Search (revocation closes it): raising a policy
> would close the contexts it no longer allows, as revocation does.
> Whether Search should be the use permission is among the points
> below.
> 7. import moves a clear key through kernel memory: an encrypted import,
> wrapped for the backend, would avoid it. Policies are global: they
> could follow namespaces, if that is wanted, and stay one-way.
> 8. The GCM stream has no seek: decryption could start at a given
> segment (keycrypt.rst leaves room for it in the open parameters);
> encryption never will, so that no counter is used twice.
> 9. OP-TEE backend: its control session is not reopened after a TA
> panic, the TA's session limit is a build constant, and every context
> has shared buffers of its own: the session would be reopened, the
> limit made configurable, and the buffers taken from a pool, as part
> of the work on the per-byte cost above.
> 10. No keyutils or man-page support yet: to be added.
>
> Other points I would like opinions on:
>
> 1. two KDFs and a stream construction living in security/keys rather
> than reusable primitives;
> 2. Search as the use permission;
> 3. an rwsem held across sleeping backend calls;
> 4. whether a KEYCTL_CAPS1_* bit telling a process once that keycrypt
> is there would help (not in this series).
>
> Not in this RFC: signatures, ECDH, encrypted import, io_uring, other
> modes; ELE code; external secure elements as backends.
>
> How this series was made
> ------------------------
>
> This work comes from a project to strengthen the secure-boot chain of
> embedded Linux systems.
>
> I used an AI coding assistant, Anthropic's Claude (claude-opus-5-5 in
> Claude Code), in the sense of
> Documentation/process/coding-assistants.rst. However, the way the
> problem is solved is mine: a new key type, so that user space can go on
> using keys it never reads while AF_ALG drops off-CPU cryptography and
> restricts what it allows, built on backends that hold the key and on
> tiers that say what a backend protects against, the engine one
> included. I directed the design and took its decisions, choosing among
> the options the assistant set out or bringing my own. The assistant
> surveyed the prior art, set out the design options with a
> recommendation at each step, and wrote the code, the KUnit tests, the
> selftests (not posted, see Testing) and the documentation under my
> direction, in plans I approved, partly through lower-tier Claude models
> it dispatched for individual tasks; each plan was followed by an AI
> review that I read.
> Claude also built and ran the QEMU bench and analysed the hardware run,
> which another Claude session carried out with me at the board.
>
> I have reviewed every patch and I am responsible for all of it.
>
> Rodolfo Giometti
>
> Rodolfo Giometti (9):
> KEYS: keycrypt: Add a key type for keys user space never reads
> KEYS: keycrypt: Add the sw backend
> KEYS: keycrypt: Add the OP-TEE backend
> docs: keycrypt: document keycrypt keys
> MAINTAINERS: add KEYS-KEYCRYPT
> KEYS: keycrypt: Add the engine tier
> crypto: caam - add an internal cbc(paes) taking the blob's key
> modifier
> KEYS: keycrypt: Add the CAAM backend
> KEYS: keycrypt: Add the aes256-gcm-stream algorithm
>
> .../admin-guide/kernel-parameters.txt | 20 +
> Documentation/security/keys/index.rst | 1 +
> Documentation/security/keys/keycrypt.rst | 1105 +++++++++++++++++
> .../userspace-api/ioctl/ioctl-number.rst | 2 +
> MAINTAINERS | 18 +
> drivers/crypto/caam/caamalg.c | 89 +-
> drivers/crypto/caam/caamalg_desc.c | 3 +-
> drivers/crypto/caam/caamalg_desc.h | 1 +
> include/keys/keycrypt.h | 161 +++
> include/soc/fsl/caam-blob.h | 8 +
> include/uapi/linux/keycrypt.h | 182 +++
> 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 | 153 +++
> security/keys/keycrypt/Makefile | 9 +
> security/keys/keycrypt/caam.c | 346 ++++++
> security/keys/keycrypt/caam.h | 30 +
> security/keys/keycrypt/core.c | 1077 ++++++++++++++++
> security/keys/keycrypt/ctx.c | 667 ++++++++++
> security/keys/keycrypt/keycrypt.h | 180 +++
> security/keys/keycrypt/optee.c | 489 ++++++++
> security/keys/keycrypt/optee.h | 39 +
> security/keys/keycrypt/sw.c | 468 +++++++
> security/keys/keycrypt/sw.h | 30 +
> security/keys/keyctl.c | 5 +
> 28 files changed, 5090 insertions(+), 12 deletions(-)
> create mode 100644 Documentation/security/keys/keycrypt.rst
> 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/caam.c
> create mode 100644 security/keys/keycrypt/caam.h
> create mode 100644 security/keys/keycrypt/core.c
> create mode 100644 security/keys/keycrypt/ctx.c
> create mode 100644 security/keys/keycrypt/keycrypt.h
> create mode 100644 security/keys/keycrypt/optee.c
> create mode 100644 security/keys/keycrypt/optee.h
> create mode 100644 security/keys/keycrypt/sw.c
> create mode 100644 security/keys/keycrypt/sw.h
>
>
> base-commit: 067c5c24cef23d913b67eaaf71ae67e7169a6620
> prerequisite-patch-id: 6f1c5a861378c58d6adea4e1745794466a9d73d6
> prerequisite-patch-id: e1565dff5540351c42ee04e0308649a6d97e9e09
> prerequisite-patch-id: 37ed62269bd4b1fcaeeab38f5feb5b0f63608459
> --
> 2.43.0
>