crash_dump: store dm crypt keys in kdump reserved memory

When the kdump kernel image and initrd are loaded, the dm crypts keys will
be read from keyring and then stored in kdump reserved memory.

Assume a key won't exceed 256 bytes thus MAX_KEY_SIZE=256 according to
"cryptsetup benchmark".

Link: https://lkml.kernel.org/r/20250502011246.99238-4-coxu@redhat.com
Signed-off-by: Coiby Xu <coxu@redhat.com>
Acked-by: Baoquan He <bhe@redhat.com>
Cc: "Daniel P. Berrange" <berrange@redhat.com>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Dave Young <dyoung@redhat.com>
Cc: Jan Pazdziora <jpazdziora@redhat.com>
Cc: Liu Pingfan <kernelfans@gmail.com>
Cc: Milan Broz <gmazyland@gmail.com>
Cc: Ondrej Kozina <okozina@redhat.com>
Cc: Vitaly Kuznetsov <vkuznets@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/crash_core.h b/include/linux/crash_core.h
index 44305336314eb45c15ceea452f9acbc0b26f2a86..2e678223903436a2f5cca3a93c764b8e6cf78eca 100644 (file)
--- a/include/linux/crash_core.h
+++ b/include/linux/crash_core.h
@@ -34,7 +34,11 @@ static inline void arch_kexec_protect_crashkres(void) { }
 static inline void arch_kexec_unprotect_crashkres(void) { }
 #endif
 
-
+#ifdef CONFIG_CRASH_DM_CRYPT
+int crash_load_dm_crypt_keys(struct kimage *image);
+#else
+static inline int crash_load_dm_crypt_keys(struct kimage *image) {return 0; }
+#endif
 
 #ifndef arch_crash_handle_hotplug_event
 static inline void arch_crash_handle_hotplug_event(struct kimage *image, void *arg) { }

diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 1871eaa9543280bb97f10cd5095e2c3897669f34..6e688c5d8e4dc9a76009139b1250c77db9ec3577 100644 (file)
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -405,6 +405,10 @@ struct kimage {
        void *elf_headers;
        unsigned long elf_headers_sz;
        unsigned long elf_load_addr;
+
+       /* dm crypt keys buffer */
+       unsigned long dm_crypt_keys_addr;
+       unsigned long dm_crypt_keys_sz;
 };
 
 /* kexec interface functions */

diff --git a/kernel/crash_dump_dm_crypt.c b/kernel/crash_dump_dm_crypt.c
index 62a3c47d8b3b36456546bea3744d1f31155e4f84..fb25f55f1512eb8e9a8065fd48a1d9f503e13d9e 100644 (file)
--- a/kernel/crash_dump_dm_crypt.c
+++ b/kernel/crash_dump_dm_crypt.c
@@ -1,14 +1,62 @@
 // SPDX-License-Identifier: GPL-2.0-only
+#include <linux/key.h>
+#include <linux/keyctl.h>
 #include <keys/user-type.h>
 #include <linux/crash_dump.h>
 #include <linux/configfs.h>
 #include <linux/module.h>
 
 #define KEY_NUM_MAX 128        /* maximum dm crypt keys */
+#define KEY_SIZE_MAX 256       /* maximum dm crypt key size */
 #define KEY_DESC_MAX_LEN 128   /* maximum dm crypt key description size */
 
 static unsigned int key_count;
 
+struct dm_crypt_key {
+       unsigned int key_size;
+       char key_desc[KEY_DESC_MAX_LEN];
+       u8 data[KEY_SIZE_MAX];
+};
+
+static struct keys_header {
+       unsigned int total_keys;
+       struct dm_crypt_key keys[] __counted_by(total_keys);
+} *keys_header;
+
+static size_t get_keys_header_size(size_t total_keys)
+{
+       return struct_size(keys_header, keys, total_keys);
+}
+
+static int read_key_from_user_keying(struct dm_crypt_key *dm_key)
+{
+       const struct user_key_payload *ukp;
+       struct key *key;
+
+       kexec_dprintk("Requesting logon key %s", dm_key->key_desc);
+       key = request_key(&key_type_logon, dm_key->key_desc, NULL);
+
+       if (IS_ERR(key)) {
+               pr_warn("No such logon key %s\n", dm_key->key_desc);
+               return PTR_ERR(key);
+       }
+
+       ukp = user_key_payload_locked(key);
+       if (!ukp)
+               return -EKEYREVOKED;
+
+       if (ukp->datalen > KEY_SIZE_MAX) {
+               pr_err("Key size %u exceeds maximum (%u)\n", ukp->datalen, KEY_SIZE_MAX);
+               return -EINVAL;
+       }
+
+       memcpy(dm_key->data, ukp->data, ukp->datalen);
+       dm_key->key_size = ukp->datalen;
+       kexec_dprintk("Get dm crypt key (size=%u) %s: %8ph\n", dm_key->key_size,
+                     dm_key->key_desc, dm_key->data);
+       return 0;
+}
+
 struct config_key {
        struct config_item item;
        const char *description;
@@ -130,6 +178,91 @@ static struct configfs_subsystem config_keys_subsys = {
        },
 };
 
+static int build_keys_header(void)
+{
+       struct config_item *item = NULL;
+       struct config_key *key;
+       int i, r;
+
+       if (keys_header != NULL)
+               kvfree(keys_header);
+
+       keys_header = kzalloc(get_keys_header_size(key_count), GFP_KERNEL);
+       if (!keys_header)
+               return -ENOMEM;
+
+       keys_header->total_keys = key_count;
+
+       i = 0;
+       list_for_each_entry(item, &config_keys_subsys.su_group.cg_children,
+                           ci_entry) {
+               if (item->ci_type != &config_key_type)
+                       continue;
+
+               key = to_config_key(item);
+
+               if (!key->description) {
+                       pr_warn("No key description for key %s\n", item->ci_name);
+                       return -EINVAL;
+               }
+
+               strscpy(keys_header->keys[i].key_desc, key->description,
+                       KEY_DESC_MAX_LEN);
+               r = read_key_from_user_keying(&keys_header->keys[i]);
+               if (r != 0) {
+                       kexec_dprintk("Failed to read key %s\n",
+                                     keys_header->keys[i].key_desc);
+                       return r;
+               }
+               i++;
+               kexec_dprintk("Found key: %s\n", item->ci_name);
+       }
+
+       return 0;
+}
+
+int crash_load_dm_crypt_keys(struct kimage *image)
+{
+       struct kexec_buf kbuf = {
+               .image = image,
+               .buf_min = 0,
+               .buf_max = ULONG_MAX,
+               .top_down = false,
+               .random = true,
+       };
+       int r;
+
+
+       if (key_count <= 0) {
+               kexec_dprintk("No dm-crypt keys\n");
+               return -ENOENT;
+       }
+
+       image->dm_crypt_keys_addr = 0;
+       r = build_keys_header();
+       if (r)
+               return r;
+
+       kbuf.buffer = keys_header;
+       kbuf.bufsz = get_keys_header_size(key_count);
+
+       kbuf.memsz = kbuf.bufsz;
+       kbuf.buf_align = ELF_CORE_HEADER_ALIGN;
+       kbuf.mem = KEXEC_BUF_MEM_UNKNOWN;
+       r = kexec_add_buffer(&kbuf);
+       if (r) {
+               kvfree((void *)kbuf.buffer);
+               return r;
+       }
+       image->dm_crypt_keys_addr = kbuf.mem;
+       image->dm_crypt_keys_sz = kbuf.bufsz;
+       kexec_dprintk(
+               "Loaded dm crypt keys to kexec_buffer bufsz=0x%lx memsz=0x%lx\n",
+               kbuf.bufsz, kbuf.memsz);
+
+       return r;
+}
+
 static int __init configfs_dmcrypt_keys_init(void)
 {
        int ret;