Skip to contentSkip to conversation

arm64: kexec_file: use more system keyrings to verify kernel image signature + dependencies

PATCH In review Michal Suchanek 4 participants 18 messages Sep 23, 2022 – Sep 27, 2022

Subsystems (6)
lore
Share & tools
lore
#0 lore raw

cover arm64: kexec_file: use more system keyrings to verify kernel image signature + dependencies

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

Some patches needed minor adjustment for context.

Thanks

Michal

Coiby Xu (3):
kexec: clean up arch_kexec_kernel_verify_sig
kexec, KEYS: make the code in bzImage64_verify_sig generic
arm64: kexec_file: use more system keyrings to verify kernel image
signature

Naveen N. Rao (2):
kexec_file: drop weak attribute from functions
kexec: drop weak attribute from functions

Sven Schnelle (1):
s390/kexec_file: move kernel image size check

 arch/arm64/include/asm/kexec.h        | 20 ++++++-
 arch/arm64/kernel/kexec_image.c       | 11 +---
 arch/powerpc/include/asm/kexec.h      | 14 +++++
 arch/s390/boot/head.S                 |  2 -
 arch/s390/include/asm/kexec.h         | 14 +++++
 arch/s390/include/asm/setup.h         |  1 -
 arch/s390/kernel/machine_kexec_file.c | 17 +-----
 arch/x86/include/asm/kexec.h          | 12 ++++
 arch/x86/kernel/kexec-bzimage64.c     | 20 +------
 include/linux/kexec.h                 | 82 ++++++++++++++++++++++----
 kernel/kexec_core.c                   | 27 ---------
 kernel/kexec_file.c                   | 83 ++++++++++-----------------
 12 files changed, 163 insertions(+), 140 deletions(-)
Signature · 1 line
2.35.3
#1 lore raw

PATCH 1/6 s390/kexec_file: move kernel image size check

From: Sven Schnelle <[email protected]>

commit 277c8389386e2ccb8417afe4e36f67fc5dcd735d upstream.

In preparation of adding support for command lines with variable sizes on s390, the check whether the new kernel image is at least HEAD_END bytes long isn't correct. Move the check to kexec_file_add_components() so we can get the size of the parm area and check the size there.

The '.org HEAD_END' directive can now also be removed from head.S. This was used in the past to reserve space for the early sccb buffer, but with commit f1d3c5323772 ("s390/boot: move sclp early buffer from fixed address in asm to C") this is no longer required.

---
 arch/s390/boot/head.S                 |  2 --
 arch/s390/include/asm/setup.h         |  1 -
 arch/s390/kernel/machine_kexec_file.c | 17 ++---------------
 3 files changed, 2 insertions(+), 18 deletions(-)
arch/s390/boot/head.S +0 -2
index 40f4cff538b8..f3a8dba7dd5d 100644
@@ -383,5 +383,3 @@ SYM_DATA_START(parmarea)
 	.byte	0
 	.org	PARMAREA+__PARMAREA_SIZE
 SYM_DATA_END(parmarea)
-
-	.org	HEAD_END
arch/s390/include/asm/setup.h +0 -1
index b6606ffd85d8..121e1a8c41d7 100644
@@ -11,7 +11,6 @@
 #include <linux/build_bug.h>
 
 #define PARMAREA		0x10400
-#define HEAD_END		0x11000
 
 /*
  * Machine features detected in early.c
arch/s390/kernel/machine_kexec_file.c +2 -15
index 3459362c54ac..29a9178ff0d4 100644
@@ -243,7 +243,8 @@ void *kexec_file_add_components(struct kimage *image,
 	if (ret)
 		goto out;
 
-	if (image->cmdline_buf_len >= ARCH_COMMAND_LINE_SIZE) {
+	if (image->kernel_buf_len < PARMAREA + sizeof(struct parmarea) ||
+	    image->cmdline_buf_len >= ARCH_COMMAND_LINE_SIZE) {
 		ret = -EINVAL;
 		goto out;
 	}
@@ -333,20 +334,6 @@ int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
 	return 0;
 }
 
-int arch_kexec_kernel_image_probe(struct kimage *image, void *buf,
-				  unsigned long buf_len)
-{
-	/* A kernel must be at least large enough to contain head.S. During
-	 * load memory in head.S will be accessed, e.g. to register the next
-	 * command line. If the next kernel were smaller the current kernel
-	 * will panic at load.
-	 */
-	if (buf_len < HEAD_END)
-		return -ENOEXEC;
-
-	return kexec_image_probe_default(image, buf, buf_len);
-}
-
 int arch_kimage_file_post_load_cleanup(struct kimage *image)
 {
 	vfree(image->arch.ipl_buf);
Signature · 1 line
2.35.3
#2 lore raw

PATCH 2/6 kexec_file: drop weak attribute from functions

In reply to Michal Suchanek

From: "Naveen N. Rao" <[email protected]>

commit 65d9a9a60fd71be964effb2e94747a6acb6e7015 upstream.

As requested
(http://lkml.kernel.org/r/[email protected]),
this series converts weak functions in kexec to use the #ifdef approach.

Quoting the 3e35142ef99fe ("kexec_file: drop weak attribute from arch_kexec_apply_relocations[_add]") changelog:

: Since commit d1bcae833b32f1 ("ELF: Don't generate unused section symbols") : [1], binutils (v2.36+) started dropping section symbols that it thought : were unused. This isn't an issue in general, but with kexec_file.c, gcc : is placing kexec_arch_apply_relocations[_add] into a separate : .text.unlikely section and the section symbol ".text.unlikely" is being : dropped. Due to this, recordmcount is unable to find a non-weak symbol in : .text.unlikely to generate a relocation record against.

This patch (of 2);

Drop __weak attribute from functions in kexec_file.c:
- arch_kexec_kernel_image_probe()
- arch_kimage_file_post_load_cleanup()
- arch_kexec_kernel_image_load()
- arch_kexec_locate_mem_hole()
- arch_kexec_kernel_verify_sig()

arch_kexec_kernel_image_load() calls into kexec_image_load_default(), so drop the static attribute for the latter.

arch_kexec_kernel_verify_sig() is not overridden by any architecture, so drop the __weak attribute.

---
 arch/arm64/include/asm/kexec.h   |  4 ++-
 arch/powerpc/include/asm/kexec.h |  9 +++++++
 arch/s390/include/asm/kexec.h    |  3 +++
 arch/x86/include/asm/kexec.h     |  6 +++++
 include/linux/kexec.h            | 44 +++++++++++++++++++++++++++-----
 kernel/kexec_file.c              | 35 ++-----------------------
 6 files changed, 61 insertions(+), 40 deletions(-)
arch/arm64/include/asm/kexec.h +3 -1
index 00dbcc71aeb2..91d81824f869 100644
@@ -103,7 +103,9 @@ extern const struct kexec_file_ops kexec_image_ops;
 
 struct kimage;
 
-extern int arch_kimage_file_post_load_cleanup(struct kimage *image);
+int arch_kimage_file_post_load_cleanup(struct kimage *image);
+#define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
+
 extern int load_other_segments(struct kimage *image,
 		unsigned long kernel_load_addr, unsigned long kernel_size,
 		char *initrd, unsigned long initrd_len,
arch/powerpc/include/asm/kexec.h +9 -0
index 88d0d7cf3a79..6152fa220054 100644
@@ -119,6 +119,15 @@ int setup_purgatory(struct kimage *image, const void *slave_code,
 #ifdef CONFIG_PPC64
 struct kexec_buf;
 
+int arch_kexec_kernel_image_probe(struct kimage *image, void *buf, unsigned long buf_len);
+#define arch_kexec_kernel_image_probe arch_kexec_kernel_image_probe
+
+int arch_kimage_file_post_load_cleanup(struct kimage *image);
+#define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
+
+int arch_kexec_locate_mem_hole(struct kexec_buf *kbuf);
+#define arch_kexec_locate_mem_hole arch_kexec_locate_mem_hole
+
 int load_crashdump_segments_ppc64(struct kimage *image,
 				  struct kexec_buf *kbuf);
 int setup_purgatory_ppc64(struct kimage *image, const void *slave_code,
arch/s390/include/asm/kexec.h +3 -0
index 63098df81c9f..d13bd221cd37 100644
@@ -92,5 +92,8 @@ int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
 				     const Elf_Shdr *relsec,
 				     const Elf_Shdr *symtab);
 #define arch_kexec_apply_relocations_add arch_kexec_apply_relocations_add
+
+int arch_kimage_file_post_load_cleanup(struct kimage *image);
+#define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
 #endif
 #endif /*_S390_KEXEC_H */
arch/x86/include/asm/kexec.h +6 -0
index c7c924e15011..5b6e2ae54906 100644
@@ -193,6 +193,12 @@ int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
 				     const Elf_Shdr *relsec,
 				     const Elf_Shdr *symtab);
 #define arch_kexec_apply_relocations_add arch_kexec_apply_relocations_add
+
+void *arch_kexec_kernel_image_load(struct kimage *image);
+#define arch_kexec_kernel_image_load arch_kexec_kernel_image_load
+
+int arch_kimage_file_post_load_cleanup(struct kimage *image);
+#define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
 #endif
 #endif
 
include/linux/kexec.h +38 -6

59 lines not on this page · raw message

kernel/kexec_file.c +2 -33
index f7a4fd4d243f..620021679405 100644
@@ -62,14 +62,7 @@ int kexec_image_probe_default(struct kimage *image, void *buf,
 	return ret;
 }
 
-/* Architectures can provide this probe function */
-int __weak arch_kexec_kernel_image_probe(struct kimage *image, void *buf,
-					 unsigned long buf_len)
-{
-	return kexec_image_probe_default(image, buf, buf_len);
-}
-
-static void *kexec_image_load_default(struct kimage *image)
+void *kexec_image_load_default(struct kimage *image)
 {
 	if (!image->fops || !image->fops->load)
 		return ERR_PTR(-ENOEXEC);
@@ -80,11 +73,6 @@ static void *kexec_image_load_default(struct kimage *image)
 				 image->cmdline_buf_len);
 }
 
-void * __weak arch_kexec_kernel_image_load(struct kimage *image)
-{
-	return kexec_image_load_default(image);
-}
-
 int kexec_image_post_load_cleanup_default(struct kimage *image)
 {
 	if (!image->fops || !image->fops->cleanup)
@@ -93,11 +81,6 @@ int kexec_image_post_load_cleanup_default(struct kimage *image)
 	return image->fops->cleanup(image->image_loader_data);
 }
 
-int __weak arch_kimage_file_post_load_cleanup(struct kimage *image)
-{
-	return kexec_image_post_load_cleanup_default(image);
-}
-
 #ifdef CONFIG_KEXEC_SIG
 static int kexec_image_verify_sig_default(struct kimage *image, void *buf,
 					  unsigned long buf_len)
@@ -110,8 +93,7 @@ static int kexec_image_verify_sig_default(struct kimage *image, void *buf,
 	return image->fops->verify_sig(buf, buf_len);
 }
 
-int __weak arch_kexec_kernel_verify_sig(struct kimage *image, void *buf,
-					unsigned long buf_len)
+int arch_kexec_kernel_verify_sig(struct kimage *image, void *buf, unsigned long buf_len)
 {
 	return kexec_image_verify_sig_default(image, buf, buf_len);
 }
@@ -616,19 +598,6 @@ int kexec_locate_mem_hole(struct kexec_buf *kbuf)
 	return ret == 1 ? 0 : -EADDRNOTAVAIL;
 }
 
-/**
- * arch_kexec_locate_mem_hole - Find free memory to place the segments.
- * @kbuf:                       Parameters for the memory search.
- *
- * On success, kbuf->mem will have the start address of the memory region found.
- *
- * Return: 0 on success, negative errno on error.
- */
-int __weak arch_kexec_locate_mem_hole(struct kexec_buf *kbuf)
-{
-	return kexec_locate_mem_hole(kbuf);
-}
-
 /**
  * kexec_add_buffer - place a buffer in a kexec segment
  * @kbuf:	Buffer contents and memory parameters.
Signature · 1 line
2.35.3
#3 lore raw

PATCH 3/6 kexec: drop weak attribute from functions

In reply to Michal Suchanek

From: "Naveen N. Rao" <[email protected]>

commit 0738eceb6201691534df07e0928d0a6168a35787 upstream.

Drop __weak attribute from functions in kexec_core.c:
- machine_kexec_post_load()
- arch_kexec_protect_crashkres()
- arch_kexec_unprotect_crashkres()
- crash_free_reserved_phys_range()

---
 arch/arm64/include/asm/kexec.h   | 18 ++++++++++++++++--
 arch/powerpc/include/asm/kexec.h |  5 +++++
 arch/s390/include/asm/kexec.h    | 11 +++++++++++
 arch/x86/include/asm/kexec.h     |  6 ++++++
 include/linux/kexec.h            | 32 ++++++++++++++++++++++++++++----
 kernel/kexec_core.c              | 27 ---------------------------
 6 files changed, 66 insertions(+), 33 deletions(-)
arch/arm64/include/asm/kexec.h +16 -2
index 91d81824f869..ae3695a15610 100644
@@ -84,12 +84,28 @@ static inline void crash_setup_regs(struct pt_regs *newregs,
 extern bool crash_is_nosave(unsigned long pfn);
 extern void crash_prepare_suspend(void);
 extern void crash_post_resume(void);
+
+void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
+#define crash_free_reserved_phys_range crash_free_reserved_phys_range
 #else
 static inline bool crash_is_nosave(unsigned long pfn) {return false; }
 static inline void crash_prepare_suspend(void) {}
 static inline void crash_post_resume(void) {}
 #endif
 
+struct kimage;
+
+#if defined(CONFIG_KEXEC_CORE)
+int machine_kexec_post_load(struct kimage *image);
+#define machine_kexec_post_load machine_kexec_post_load
+
+void arch_kexec_protect_crashkres(void);
+#define arch_kexec_protect_crashkres arch_kexec_protect_crashkres
+
+void arch_kexec_unprotect_crashkres(void);
+#define arch_kexec_unprotect_crashkres arch_kexec_unprotect_crashkres
+#endif
+
 #define ARCH_HAS_KIMAGE_ARCH
 
 struct kimage_arch {
@@ -101,8 +117,6 @@ struct kimage_arch {
 #ifdef CONFIG_KEXEC_FILE
 extern const struct kexec_file_ops kexec_image_ops;
 
-struct kimage;
-
 int arch_kimage_file_post_load_cleanup(struct kimage *image);
 #define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
 
arch/powerpc/include/asm/kexec.h +5 -0
index 6152fa220054..d8394e77e987 100644
@@ -97,6 +97,11 @@ static inline bool kdump_in_progress(void)
 void relocate_new_kernel(unsigned long indirection_page, unsigned long reboot_code_buffer,
 			 unsigned long start_address) __noreturn;
 
+#if defined(CONFIG_CRASH_DUMP) && defined(CONFIG_PPC_RTAS)
+void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
+#define crash_free_reserved_phys_range crash_free_reserved_phys_range
+#endif
+
 #ifdef CONFIG_KEXEC_FILE
 extern const struct kexec_file_ops kexec_elf64_ops;
 
arch/s390/include/asm/kexec.h +11 -0
index d13bd221cd37..4f713092e68c 100644
@@ -85,6 +85,17 @@ struct kimage_arch {
 extern const struct kexec_file_ops s390_kexec_image_ops;
 extern const struct kexec_file_ops s390_kexec_elf_ops;
 
+#ifdef CONFIG_CRASH_DUMP
+void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
+#define crash_free_reserved_phys_range crash_free_reserved_phys_range
+
+void arch_kexec_protect_crashkres(void);
+#define arch_kexec_protect_crashkres arch_kexec_protect_crashkres
+
+void arch_kexec_unprotect_crashkres(void);
+#define arch_kexec_unprotect_crashkres arch_kexec_unprotect_crashkres
+#endif
+
 #ifdef CONFIG_KEXEC_FILE
 struct purgatory_info;
 int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
arch/x86/include/asm/kexec.h +6 -0
index 5b6e2ae54906..4fd92330f23d 100644
@@ -186,6 +186,12 @@ extern int arch_kexec_post_alloc_pages(void *vaddr, unsigned int pages,
 extern void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages);
 #define arch_kexec_pre_free_pages arch_kexec_pre_free_pages
 
+void arch_kexec_protect_crashkres(void);
+#define arch_kexec_protect_crashkres arch_kexec_protect_crashkres
+
+void arch_kexec_unprotect_crashkres(void);
+#define arch_kexec_unprotect_crashkres arch_kexec_unprotect_crashkres
+
 #ifdef CONFIG_KEXEC_FILE
 struct purgatory_info;
 int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
include/linux/kexec.h +28 -4
index f1e5327a7bf8..1638c8d7d216 100644
@@ -384,7 +384,10 @@ extern void machine_kexec_cleanup(struct kimage *image);
 extern int kernel_kexec(void);
 extern struct page *kimage_alloc_control_pages(struct kimage *image,
 						unsigned int order);
-int machine_kexec_post_load(struct kimage *image);
+
+#ifndef machine_kexec_post_load
+static inline int machine_kexec_post_load(struct kimage *image) { return 0; }
+#endif
 
 extern void __crash_kexec(struct pt_regs *);
 extern void crash_kexec(struct pt_regs *);
@@ -423,10 +426,21 @@ extern bool kexec_in_progress;
 
 int crash_shrink_memory(unsigned long new_size);
 size_t crash_get_memory_size(void);
-void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
 
-void arch_kexec_protect_crashkres(void);
-void arch_kexec_unprotect_crashkres(void);
+#ifndef arch_kexec_protect_crashkres
+/*
+ * Protection mechanism for crashkernel reserved memory after
+ * the kdump kernel is loaded.
+ *
+ * Provide an empty default implementation here -- architecture
+ * code may override this
+ */
+static inline void arch_kexec_protect_crashkres(void) { }
+#endif
+
+#ifndef arch_kexec_unprotect_crashkres
+static inline void arch_kexec_unprotect_crashkres(void) { }
+#endif
 
 #ifndef page_to_boot_pfn
 static inline unsigned long page_to_boot_pfn(struct page *page)
@@ -456,6 +470,16 @@ static inline phys_addr_t boot_phys_to_phys(unsigned long boot_phys)
 }
 #endif
 
+#ifndef crash_free_reserved_phys_range
+static inline void crash_free_reserved_phys_range(unsigned long begin, unsigned long end)
+{
+	unsigned long addr;
+
+	for (addr = begin; addr < end; addr += PAGE_SIZE)
+		free_reserved_page(boot_pfn_to_page(addr >> PAGE_SHIFT));
+}
+#endif
+
 static inline unsigned long virt_to_boot_phys(void *addr)
 {
 	return phys_to_boot_phys(__pa((unsigned long)addr));
kernel/kexec_core.c +0 -27
index 5a5d192a89ac..0951df148c1e 100644
@@ -591,11 +591,6 @@ static void kimage_free_extra_pages(struct kimage *image)
 
 }
 
-int __weak machine_kexec_post_load(struct kimage *image)
-{
-	return 0;
-}
-
 void kimage_terminate(struct kimage *image)
 {
 	if (*image->entry != 0)
@@ -1000,15 +995,6 @@ size_t crash_get_memory_size(void)
 	return size;
 }
 
-void __weak crash_free_reserved_phys_range(unsigned long begin,
-					   unsigned long end)
-{
-	unsigned long addr;
-
-	for (addr = begin; addr < end; addr += PAGE_SIZE)
-		free_reserved_page(boot_pfn_to_page(addr >> PAGE_SHIFT));
-}
-
 int crash_shrink_memory(unsigned long new_size)
 {
 	int ret = 0;
@@ -1205,16 +1191,3 @@ int kernel_kexec(void)
 	mutex_unlock(&kexec_mutex);
 	return error;
 }
-
-/*
- * Protection mechanism for crashkernel reserved memory after
- * the kdump kernel is loaded.
- *
- * Provide an empty default implementation here -- architecture
- * code may override this
- */
-void __weak arch_kexec_protect_crashkres(void)
-{}
-
-void __weak arch_kexec_unprotect_crashkres(void)
-{}
Signature · 1 line
2.35.3
#4 lore raw

PATCH 4/6 kexec: clean up arch_kexec_kernel_verify_sig

In reply to Michal Suchanek

From: Coiby Xu <[email protected]>

commit 689a71493bd2f31c024f8c0395f85a1fd4b2138e upstream.

Before commit 105e10e2cf1c ("kexec_file: drop weak attribute from functions"), there was already no arch-specific implementation of arch_kexec_kernel_verify_sig. With weak attribute dropped by that commit, arch_kexec_kernel_verify_sig is completely useless. So clean it up.

Note later patches are dependent on this patch so it should be backported to the stable tree as well.

---
 include/linux/kexec.h |  5 -----
 kernel/kexec_file.c   | 33 +++++++++++++--------------------
 2 files changed, 13 insertions(+), 25 deletions(-)
include/linux/kexec.h +0 -5
index 1638c8d7d216..46f113961dbc 100644
@@ -206,11 +206,6 @@ static inline void *arch_kexec_kernel_image_load(struct kimage *image)
 }
 #endif
 
-#ifdef CONFIG_KEXEC_SIG
-int arch_kexec_kernel_verify_sig(struct kimage *image, void *buf,
-				 unsigned long buf_len);
-#endif
-
 extern int kexec_add_buffer(struct kexec_buf *kbuf);
 int kexec_locate_mem_hole(struct kexec_buf *kbuf);
 
kernel/kexec_file.c +13 -20
index 620021679405..8d73d6d4f0a6 100644
@@ -81,24 +81,6 @@ int kexec_image_post_load_cleanup_default(struct kimage *image)
 	return image->fops->cleanup(image->image_loader_data);
 }
 
-#ifdef CONFIG_KEXEC_SIG
-static int kexec_image_verify_sig_default(struct kimage *image, void *buf,
-					  unsigned long buf_len)
-{
-	if (!image->fops || !image->fops->verify_sig) {
-		pr_debug("kernel loader does not support signature verification.\n");
-		return -EKEYREJECTED;
-	}
-
-	return image->fops->verify_sig(buf, buf_len);
-}
-
-int arch_kexec_kernel_verify_sig(struct kimage *image, void *buf, unsigned long buf_len)
-{
-	return kexec_image_verify_sig_default(image, buf, buf_len);
-}
-#endif
-
 /*
  * Free up memory used by kernel, initrd, and command line. This is temporary
  * memory allocation which is not needed any more after these buffers have
@@ -141,13 +123,24 @@ void kimage_file_post_load_cleanup(struct kimage *image)
 }
 
 #ifdef CONFIG_KEXEC_SIG
+static int kexec_image_verify_sig(struct kimage *image, void *buf,
+				  unsigned long buf_len)
+{
+	if (!image->fops || !image->fops->verify_sig) {
+		pr_debug("kernel loader does not support signature verification.\n");
+		return -EKEYREJECTED;
+	}
+
+	return image->fops->verify_sig(buf, buf_len);
+}
+
 static int
 kimage_validate_signature(struct kimage *image)
 {
 	int ret;
 
-	ret = arch_kexec_kernel_verify_sig(image, image->kernel_buf,
-					   image->kernel_buf_len);
+	ret = kexec_image_verify_sig(image, image->kernel_buf,
+				     image->kernel_buf_len);
 	if (ret) {
 
 		if (sig_enforce) {
Signature · 1 line
2.35.3
#5 lore raw

PATCH 5/6 kexec, KEYS: make the code in bzImage64_verify_sig generic

In reply to Michal Suchanek

From: Coiby Xu <[email protected]>

commit c903dae8941deb55043ee46ded29e84e97cd84bb upstream.

commit 278311e417be ("kexec, KEYS: Make use of platform keyring for signature verify") adds platform keyring support on x86 kexec but not arm64.

The code in bzImage64_verify_sig uses the keys on the .builtin_trusted_keys, .machine, if configured and enabled, .secondary_trusted_keys, also if configured, and .platform keyrings to verify the signed kernel image as PE file.

---
 arch/x86/kernel/kexec-bzimage64.c | 20 +-------------------
 include/linux/kexec.h             |  7 +++++++
 kernel/kexec_file.c               | 17 +++++++++++++++++
 3 files changed, 25 insertions(+), 19 deletions(-)
arch/x86/kernel/kexec-bzimage64.c +1 -19
index 170d0fd68b1f..f299b48f9c9f 100644
@@ -17,7 +17,6 @@
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/efi.h>
-#include <linux/verification.h>
 
 #include <asm/bootparam.h>
 #include <asm/setup.h>
@@ -528,28 +527,11 @@ static int bzImage64_cleanup(void *loader_data)
 	return 0;
 }
 
-#ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG
-static int bzImage64_verify_sig(const char *kernel, unsigned long kernel_len)
-{
-	int ret;
-
-	ret = verify_pefile_signature(kernel, kernel_len,
-				      VERIFY_USE_SECONDARY_KEYRING,
-				      VERIFYING_KEXEC_PE_SIGNATURE);
-	if (ret == -ENOKEY && IS_ENABLED(CONFIG_INTEGRITY_PLATFORM_KEYRING)) {
-		ret = verify_pefile_signature(kernel, kernel_len,
-					      VERIFY_USE_PLATFORM_KEYRING,
-					      VERIFYING_KEXEC_PE_SIGNATURE);
-	}
-	return ret;
-}
-#endif
-
 const struct kexec_file_ops kexec_bzImage64_ops = {
 	.probe = bzImage64_probe,
 	.load = bzImage64_load,
 	.cleanup = bzImage64_cleanup,
 #ifdef CONFIG_KEXEC_BZIMAGE_VERIFY_SIG
-	.verify_sig = bzImage64_verify_sig,
+	.verify_sig = kexec_kernel_verify_pe_sig,
 #endif
 };
include/linux/kexec.h +7 -0
index 46f113961dbc..1dd7b679fcf9 100644
@@ -19,6 +19,7 @@
 #include <asm/io.h>
 
 #include <uapi/linux/kexec.h>
+#include <linux/verification.h>
 
 #ifdef CONFIG_KEXEC_CORE
 #include <linux/list.h>
@@ -206,6 +207,12 @@ static inline void *arch_kexec_kernel_image_load(struct kimage *image)
 }
 #endif
 
+#ifdef CONFIG_KEXEC_SIG
+#ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION
+int kexec_kernel_verify_pe_sig(const char *kernel, unsigned long kernel_len);
+#endif
+#endif
+
 extern int kexec_add_buffer(struct kexec_buf *kbuf);
 int kexec_locate_mem_hole(struct kexec_buf *kbuf);
 
kernel/kexec_file.c +17 -0
index 8d73d6d4f0a6..289bb20e6075 100644
@@ -123,6 +123,23 @@ void kimage_file_post_load_cleanup(struct kimage *image)
 }
 
 #ifdef CONFIG_KEXEC_SIG
+#ifdef CONFIG_SIGNED_PE_FILE_VERIFICATION
+int kexec_kernel_verify_pe_sig(const char *kernel, unsigned long kernel_len)
+{
+	int ret;
+
+	ret = verify_pefile_signature(kernel, kernel_len,
+				      VERIFY_USE_SECONDARY_KEYRING,
+				      VERIFYING_KEXEC_PE_SIGNATURE);
+	if (ret == -ENOKEY && IS_ENABLED(CONFIG_INTEGRITY_PLATFORM_KEYRING)) {
+		ret = verify_pefile_signature(kernel, kernel_len,
+					      VERIFY_USE_PLATFORM_KEYRING,
+					      VERIFYING_KEXEC_PE_SIGNATURE);
+	}
+	return ret;
+}
+#endif
+
 static int kexec_image_verify_sig(struct kimage *image, void *buf,
 				  unsigned long buf_len)
 {
Signature · 1 line
2.35.3
#6 lore raw

PATCH 6/6 arm64: kexec_file: use more system keyrings to verify kernel image signature

In reply to Michal Suchanek

From: Coiby Xu <[email protected]>

commit 0d519cadf75184a24313568e7f489a7fc9b1be3b upstream.

Currently, when loading a kernel image via the kexec_file_load() system call, arm64 can only use the .builtin_trusted_keys keyring to verify a signature whereas x86 can use three more keyrings i.e. .secondary_trusted_keys, .machine and .platform keyrings. For example, one resulting problem is kexec'ing a kernel image would be rejected with the error "Lockdown: kexec: kexec of unsigned images is restricted; see man kernel_lockdown.7".

This patch set enables arm64 to make use of the same keyrings as x86 to verify the signature kexec'ed kernel image.

Fixes 732b7b93d849 ("arm64: kexec_file: add kernel signature verification support")
Cc [email protected] # 105e10e2cf1c: kexec_file: drop weak attribute from functions
Cc [email protected] # 34d5960af253: kexec: clean up arch_kexec_kernel_verify_sig
Cc [email protected] # 83b7bb2d49ae: kexec, KEYS: make the code in bzImage64_verify_sig generic
---
 arch/arm64/kernel/kexec_image.c | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)
arch/arm64/kernel/kexec_image.c +1 -10
index 9ec34690e255..5ed6a585f21f 100644
@@ -14,7 +14,6 @@
 #include <linux/kexec.h>
 #include <linux/pe.h>
 #include <linux/string.h>
-#include <linux/verification.h>
 #include <asm/byteorder.h>
 #include <asm/cpufeature.h>
 #include <asm/image.h>
@@ -130,18 +129,10 @@ static void *image_load(struct kimage *image,
 	return NULL;
 }
 
-#ifdef CONFIG_KEXEC_IMAGE_VERIFY_SIG
-static int image_verify_sig(const char *kernel, unsigned long kernel_len)
-{
-	return verify_pefile_signature(kernel, kernel_len, NULL,
-				       VERIFYING_KEXEC_PE_SIGNATURE);
-}
-#endif
-
 const struct kexec_file_ops kexec_image_ops = {
 	.probe = image_probe,
 	.load = image_load,
 #ifdef CONFIG_KEXEC_IMAGE_VERIFY_SIG
-	.verify_sig = image_verify_sig,
+	.verify_sig = kexec_kernel_verify_pe_sig,
 #endif
 };
Signature · 1 line
2.35.3
#7 lore raw
In reply to Michal Suchanek
Quoted 7 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

Some patches needed minor adjustment for context.

In general when backporting this patch set, there should be a dependency on backporting these commits as well. In this instance for linux-5.15.y, they've already been backported.

543ce63b664e ("lockdown: Fix kexec lockdown bypass with ima policy") af16df54b89d ("ima: force signature verification when CONFIG_KEXEC_SIG is configured")

Signature · 9 lines
thanks,

Mimi


_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
#8 lore raw

Hello,

Quoted 7 lines · Mimi Zohar
Quoted 6 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

Quoted 8 lines
Quoted 1 line

Some patches needed minor adjustment for context.

In general when backporting this patch set, there should be a dependency on backporting these commits as well. In this instance for linux-5.15.y, they've already been backported.

543ce63b664e ("lockdown: Fix kexec lockdown bypass with ima policy") af16df54b89d ("ima: force signature verification when CONFIG_KEXEC_SIG is configured")

Thanks for bringing these up. It might be in general useful to backport these fixes as well.

However, this patchset does one very specific thing: it lifts the x86 kexec_file signature verification to arch-independent and uses it on arm64 to unify all features (and any existing warts) between EFI architectures.

So unless I am missing something the fixes you pointed out are completely independent of this.

Thanks

Michal

#9 lore raw
Quoted 17 lines · Michal Suchánek

Hello,

Quoted 14 lines · Mimi Zohar
Quoted 7 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

Some patches needed minor adjustment for context.

In general when backporting this patch set, there should be a dependency on backporting these commits as well. In this instance for linux-5.15.y, they've already been backported.

543ce63b664e ("lockdown: Fix kexec lockdown bypass with ima policy")

AFAICT this is everywhere relevant, likely because it's considered a CVE fix.

Quoted 1 line
Quoted 1 line

af16df54b89d ("ima: force signature verification when CONFIG_KEXEC_SIG is configured")

This is missing in 5.4, and 5.4 is missing this prerequisite:
fd7af71be542 ("kexec: do not verify the signature without the lockdown or mandatory signature")

Quoted 15 lines

Thanks for bringing these up. It might be in general useful to backport these fixes as well.

However, this patchset does one very specific thing: it lifts the x86 kexec_file signature verification to arch-independent and uses it on arm64 to unify all features (and any existing warts) between EFI architectures.

So unless I am missing something the fixes you pointed out are completely independent of this.

Thanks

Michal

#10 lore raw
In reply to Michal Suchanek
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

thanks,

greg k-h

#11 lore raw
Quoted 7 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

Quoted 6 lines

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Thanks

Michal

#12 lore raw
Quoted 11 lines · Michal Suchánek
Quoted 10 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Quoted 8 lines
Quoted 3 lines

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Ok, so it's something that never worked. Adding support to get it to work doesn't really fall into the stable kernel rules, right?

Again, what's wrong with 5.19 for anyone who wants this? Who does want this?

thanks,

greg k-h

_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec

#13 lore raw
Quoted 16 lines · Greg Kroah-Hartman
Quoted 15 lines · Michal Suchánek
Quoted 13 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

Quoted 7 lines
Quoted 4 lines

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Ok, so it's something that never worked. Adding support to get it to work doesn't really fall into the stable kernel rules, right?

Not sure. It was defective, not using the facilities available at the time correctly. Which translates to kernels that can be kexec'd on x86 failing to kexec on arm64 without any explanation (signed with same key, built for the appropriate arch).

Quoted 2 lines

Again, what's wrong with 5.19 for anyone who wants this? Who does want this?

Not sure, really.

The final patch was repeatedly backported to stable and failed to build because the prerequisites were missing.

So this is a backport that includes the prerequisites for it to build.

If nobody wanted this why is it repeatedly backported generating the failure messages?

Thanks

Michal

#14 lore raw
Quoted 22 lines · Michal Suchánek
Quoted 21 lines · Greg Kroah-Hartman
Quoted 19 lines · Michal Suchánek
Quoted 7 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

Quoted 6 lines

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Quoted 7 lines
Quoted 2 lines

Ok, so it's something that never worked. Adding support to get it to work doesn't really fall into the stable kernel rules, right?

Not sure. It was defective, not using the facilities available at the time correctly. Which translates to kernels that can be kexec'd on x86 failing to kexec on arm64 without any explanation (signed with same key, built for the appropriate arch).

Feature parity across architectures is not a "regression", but rather a "this feature is not implemented for this architecture yet" type of thing.

Quoted 7 lines
Quoted 2 lines

Again, what's wrong with 5.19 for anyone who wants this? Who does want this?

Not sure, really.

The final patch was repeatedly backported to stable and failed to build because the prerequisites were missing.

That's because it was tagged, but now that you show the full set of requirements, it's pretty obvious to me that this is not relevant for going this far back.

thanks,

greg k-h

#15 lore raw
Quoted 26 lines · Greg Kroah-Hartman
Quoted 25 lines · Michal Suchánek
Quoted 23 lines · Greg Kroah-Hartman
Quoted 11 lines · Michal Suchánek
Quoted 10 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Quoted 8 lines
Quoted 3 lines

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Ok, so it's something that never worked. Adding support to get it to work doesn't really fall into the stable kernel rules, right?

Quoted 8 lines
Quoted 4 lines

Not sure. It was defective, not using the facilities available at the time correctly. Which translates to kernels that can be kexec'd on x86 failing to kexec on arm64 without any explanation (signed with same key, built for the appropriate arch).

Feature parity across architectures is not a "regression", but rather a "this feature is not implemented for this architecture yet" type of thing.

That depends on the view - before kexec verification you could boot any kernel, now you can boot some kernels signed with a valid key, but not others - the initial implementation is buggy, probably because it is based on an old version of the x86 code.

Quoted 4 lines
Quoted 4 lines
Quoted 3 lines

Again, what's wrong with 5.19 for anyone who wants this? Who does want this?

Quoted 8 lines
Quoted 4 lines

Not sure, really.

The final patch was repeatedly backported to stable and failed to build because the prerequisites were missing.

That's because it was tagged, but now that you show the full set of requirements, it's pretty obvious to me that this is not relevant for going this far back.

That also works.

Thanks

Michal

#16 lore raw
Quoted 32 lines · Michal Such??nek
Quoted 31 lines · Greg Kroah-Hartman
Quoted 29 lines · Michal Suchánek
Quoted 16 lines · Greg Kroah-Hartman
Quoted 15 lines · Michal Suchánek
Quoted 13 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

Quoted 7 lines
Quoted 4 lines

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Ok, so it's something that never worked. Adding support to get it to work doesn't really fall into the stable kernel rules, right?

Not sure. It was defective, not using the facilities available at the time correctly. Which translates to kernels that can be kexec'd on x86 failing to kexec on arm64 without any explanation (signed with same key, built for the appropriate arch).

Quoted 8 lines
Quoted 3 lines

Feature parity across architectures is not a "regression", but rather a "this feature is not implemented for this architecture yet" type of thing.

That depends on the view - before kexec verification you could boot any kernel, now you can boot some kernels signed with a valid key, but not others - the initial implementation is buggy, probably because it is based on an old version of the x86 code.

Buggy?
The feature of supporting platform ring had been slipped in just before I submitted the latest patch series which was eventually merged. (I should have noticed it though.)

Looking at changes in the commit 278311e417be ("kexec, KEYS: Make use of platform keyring for signature verify"), it seems to be obvious that it is a new feature because it introduced a new Kconfig option, CONFIG_INTEGRITY_PLATFORM_KEYRING, which allows for enabling/disabling platform ring support.

-Takahiro Akashi

Quoted 18 lines
Quoted 4 lines
Quoted 4 lines
Quoted 3 lines

Again, what's wrong with 5.19 for anyone who wants this? Who does want this?

Quoted 8 lines
Quoted 4 lines

Not sure, really.

The final patch was repeatedly backported to stable and failed to build because the prerequisites were missing.

That's because it was tagged, but now that you show the full set of requirements, it's pretty obvious to me that this is not relevant for going this far back.

That also works.

Thanks

Michal

#17 lore raw
Quoted 42 lines · AKASHI Takahiro
Quoted 32 lines · Michal Such??nek
Quoted 31 lines · Greg Kroah-Hartman
Quoted 29 lines · Michal Suchánek
Quoted 16 lines · Greg Kroah-Hartman
Quoted 15 lines · Michal Suchánek
Quoted 13 lines · Greg Kroah-Hartman
Quoted 5 lines · Michal Suchanek

Hello,

this is backport of commit 0d519cadf751
("arm64: kexec_file: use more system keyrings to verify kernel image signature") to table 5.15 tree including the preparatory patches.

This feels to me like a new feature for arm64, one that has never worked before and you are just making it feature-parity with x86, right?

Or is this a regression fix somewhere? Why is this needed in 5.15.y and why can't people who need this new feature just use a newer kernel version (5.19?)

Quoted 7 lines
Quoted 4 lines

It's half-broken implementation of the kexec kernel verification. At the time it was implemented for arm64 we had the platform and secondary keyrings and x86 was using them but on arm64 the initial implementation ignores them.

Ok, so it's something that never worked. Adding support to get it to work doesn't really fall into the stable kernel rules, right?

Not sure. It was defective, not using the facilities available at the time correctly. Which translates to kernels that can be kexec'd on x86 failing to kexec on arm64 without any explanation (signed with same key, built for the appropriate arch).

Quoted 8 lines
Quoted 3 lines

Feature parity across architectures is not a "regression", but rather a "this feature is not implemented for this architecture yet" type of thing.

That depends on the view - before kexec verification you could boot any kernel, now you can boot some kernels signed with a valid key, but not others - the initial implementation is buggy, probably because it is based on an old version of the x86 code.

Quoted 4 lines

Buggy?
The feature of supporting platform ring had been slipped in just before I submitted the latest patch series which was eventually merged. (I should have noticed it though.)

It's difficult to notice another in-flight patch that does not conflict with yours, and is for a different architecture. That's why we have followup patches and Fixes tags.

However, the support for secondary keyring was added in 4.19 by commit ea93102f3224 ("Fix kexec forbidding kernels signed with keys in the secondary keyring to boot") which was not supported by the arm64 code either.

Quoted 4 lines

Looking at changes in the commit 278311e417be ("kexec, KEYS: Make use of platform keyring for signature verify"), it seems to be obvious that it is a new feature because it introduced a new Kconfig option, CONFIG_INTEGRITY_PLATFORM_KEYRING, which allows for enabling/disabling platform ring support.

Yes, and that feature exists since 5.1, and we are talking about 5.15 here. Not making use of the keyring that is supported by the kernel results in inability to kexec kernels that are signed by a valid key, arguably a bug.

Thanks

Michal

_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec