Commit 479e5854 authored by Coiby Xu's avatar Coiby Xu Committed by Andrew Morton
Browse files

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: default avatarCoiby Xu <coxu@redhat.com>
Acked-by: default avatarBaoquan 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: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 180cf31a

include/linux/crash_core.h

+5 −1
Original line number Diff line number Diff line
@@ -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) { }

include/linux/kexec.h

+4 −0
Original line number Diff line number Diff line
@@ -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 */

kernel/crash_dump_dm_crypt.c

+133 −0
Original line number Diff line number Diff line 
// 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;