From 646ac5c07196bc3680e34188e55c8cc3565f65e7 Mon Sep 17 00:00:00 2001

From: David Howells <dhowells@redhat.com>

Date: Wed, 24 May 2017 14:56:00 +0100

Subject: [PATCH 01/26] Add the ability to lock down access to the running

 kernel image

Provide a single call to allow kernel code to determine whether the system

should be locked down, thereby disallowing various accesses that might

allow the running kernel image to be changed including the loading of

modules that aren't validly signed with a key we recognise, fiddling with

MSR registers and disallowing hibernation,

Signed-off-by: David Howells <dhowells@redhat.com>

Acked-by: James Morris <james.l.morris@oracle.com>

---

 include/linux/kernel.h   | 17 ++++++++++++++

 include/linux/security.h |  8 +++++++

 security/Kconfig         |  8 +++++++

 security/Makefile        |  3 +++

 security/lock_down.c     | 60 ++++++++++++++++++++++++++++++++++++++++++++++++

 5 files changed, 96 insertions(+)

 create mode 100644 security/lock_down.c

diff --git a/include/linux/kernel.h b/include/linux/kernel.h

index 0ad4c3044cf9..362da2e4bf53 100644

--- a/include/linux/kernel.h

+++ b/include/linux/kernel.h

@@ -287,6 +287,23 @@ static inline void refcount_error_report(struct pt_regs *regs, const char *err)

 { }

 #endif

+#ifdef CONFIG_LOCK_DOWN_KERNEL

+extern bool __kernel_is_locked_down(const char *what, bool first);

+#else

+static inline bool __kernel_is_locked_down(const char *what, bool first)

+{

+	return false;

+}

+#endif

+

+#define kernel_is_locked_down(what)					\

+	({								\

+		static bool message_given;				\

+		bool locked_down = __kernel_is_locked_down(what, !message_given); \

+		message_given = true;					\

+		locked_down;						\

+	})

+

 /* Internal, do not use. */

 int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);

 int __must_check _kstrtol(const char *s, unsigned int base, long *res);

diff --git a/include/linux/security.h b/include/linux/security.h

index ce6265960d6c..310775476b68 100644

--- a/include/linux/security.h

+++ b/include/linux/security.h

@@ -1753,5 +1753,13 @@ static inline void free_secdata(void *secdata)

 { }

 #endif /* CONFIG_SECURITY */

+#ifdef CONFIG_LOCK_DOWN_KERNEL

+extern void __init init_lockdown(void);

+#else

+static inline void __init init_lockdown(void)

+{

+}

+#endif

+

 #endif /* ! __LINUX_SECURITY_H */

diff --git a/security/Kconfig b/security/Kconfig

index e8e449444e65..8e01fd59ae7e 100644

--- a/security/Kconfig

+++ b/security/Kconfig

@@ -205,6 +205,14 @@ config STATIC_USERMODEHELPER_PATH

 	  If you wish for all usermode helper programs to be disabled,

 	  specify an empty string here (i.e. "").

+config LOCK_DOWN_KERNEL

+	bool "Allow the kernel to be 'locked down'"

+	help

+	  Allow the kernel to be locked down under certain circumstances, for

+	  instance if UEFI secure boot is enabled.  Locking down the kernel

+	  turns off various features that might otherwise allow access to the

+	  kernel image (eg. setting MSR registers).

+

 source security/selinux/Kconfig

 source security/smack/Kconfig

 source security/tomoyo/Kconfig

diff --git a/security/Makefile b/security/Makefile

index f2d71cdb8e19..8c4a43e3d4e0 100644

--- a/security/Makefile

+++ b/security/Makefile

@@ -29,3 +29,6 @@ obj-$(CONFIG_CGROUP_DEVICE)		+= device_cgroup.o

 # Object integrity file lists

 subdir-$(CONFIG_INTEGRITY)		+= integrity

 obj-$(CONFIG_INTEGRITY)			+= integrity/

+

+# Allow the kernel to be locked down

+obj-$(CONFIG_LOCK_DOWN_KERNEL)		+= lock_down.o

diff --git a/security/lock_down.c b/security/lock_down.c

new file mode 100644

index 000000000000..d8595c0e6673

--- /dev/null

+++ b/security/lock_down.c

@@ -0,0 +1,60 @@

+/* Lock down the kernel

+ *

+ * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.

+ * Written by David Howells (dhowells@redhat.com)

+ *

+ * This program is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU General Public Licence

+ * as published by the Free Software Foundation; either version

+ * 2 of the Licence, or (at your option) any later version.

+ */

+

+#include <linux/security.h>

+#include <linux/export.h>

+

+static __ro_after_init bool kernel_locked_down;

+

+/*

+ * Put the kernel into lock-down mode.

+ */

+static void __init lock_kernel_down(const char *where)

+{

+	if (!kernel_locked_down) {

+		kernel_locked_down = true;

+		pr_notice("Kernel is locked down from %s; see man kernel_lockdown.7\n",

+			  where);

+	}

+}

+

+static int __init lockdown_param(char *ignored)

+{

+	lock_kernel_down("command line");

+	return 0;

+}

+

+early_param("lockdown", lockdown_param);

+

+/*

+ * Lock the kernel down from very early in the arch setup.  This must happen

+ * prior to things like ACPI being initialised.

+ */

+void __init init_lockdown(void)

+{

+#ifdef CONFIG_LOCK_DOWN_IN_EFI_SECURE_BOOT

+	if (efi_enabled(EFI_SECURE_BOOT))

+		lock_kernel_down("EFI secure boot");

+#endif

+}

+

+/**

+ * kernel_is_locked_down - Find out if the kernel is locked down

+ * @what: Tag to use in notice generated if lockdown is in effect

+ */

+bool __kernel_is_locked_down(const char *what, bool first)

+{

+	if (what && first && kernel_locked_down)

+		pr_notice("Lockdown: %s is restricted; see man kernel_lockdown.7\n",

+			  what);

+	return kernel_locked_down;

+}

+EXPORT_SYMBOL(__kernel_is_locked_down);

-- 

2.13.6

From 2c46467f43bc54324de5474a8355f98c692309e4 Mon Sep 17 00:00:00 2001

From: Kyle McMartin <kyle@redhat.com>

Date: Wed, 18 Oct 2017 14:02:25 +0100

Subject: [PATCH 02/26] Add a SysRq option to lift kernel lockdown

Make an option to provide a sysrq key that will lift the kernel lockdown,

thereby allowing the running kernel image to be accessed and modified.

On x86_64 this is triggered with SysRq+x, but this key may not be available

on all arches, so it is set by setting LOCKDOWN_LIFT_KEY in asm/setup.h.

Signed-off-by: Kyle McMartin <kyle@redhat.com>

Signed-off-by: David Howells <dhowells@redhat.com>

cc: x86@kernel.org

---

 arch/x86/include/asm/setup.h |  2 ++

 drivers/input/misc/uinput.c  |  1 +

 drivers/tty/sysrq.c          | 19 ++++++++++++------

 include/linux/input.h        |  5 +++++

 include/linux/sysrq.h        |  8 +++++++-

 kernel/debug/kdb/kdb_main.c  |  2 +-

 security/Kconfig             |  8 ++++++++

 security/lock_down.c         | 47 ++++++++++++++++++++++++++++++++++++++++++++

 8 files changed, 84 insertions(+), 8 deletions(-)

diff --git a/arch/x86/include/asm/setup.h b/arch/x86/include/asm/setup.h

index a65cf544686a..863f77582c09 100644

--- a/arch/x86/include/asm/setup.h

+++ b/arch/x86/include/asm/setup.h

@@ -8,6 +8,8 @@

 #include <linux/linkage.h>

 #include <asm/page_types.h>

+#define LOCKDOWN_LIFT_KEY 'x'

+

 #ifdef __i386__

 #include <linux/pfn.h>

diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c

index 39ddd9a73feb..0afeef1672bc 100644

--- a/drivers/input/misc/uinput.c

+++ b/drivers/input/misc/uinput.c

@@ -362,6 +362,7 @@ static int uinput_create_device(struct uinput_device *udev)

 		dev->flush = uinput_dev_flush;

 	}

+	dev->flags |= INPUTDEV_FLAGS_SYNTHETIC;

 	dev->event = uinput_dev_event;

 	input_set_drvdata(udev->dev, udev);

diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c

index 3ffc1ce29023..8b766dbad6dd 100644

--- a/drivers/tty/sysrq.c

+++ b/drivers/tty/sysrq.c

@@ -481,6 +481,7 @@ static struct sysrq_key_op *sysrq_key_table[36] = {

 	/* x: May be registered on mips for TLB dump */

 	/* x: May be registered on ppc/powerpc for xmon */

 	/* x: May be registered on sparc64 for global PMU dump */

+	/* x: May be registered on x86_64 for disabling secure boot */

 	NULL,				/* x */

 	/* y: May be registered on sparc64 for global register dump */

 	NULL,				/* y */

@@ -524,7 +525,7 @@ static void __sysrq_put_key_op(int key, struct sysrq_key_op *op_p)

                 sysrq_key_table[i] = op_p;

 }

-void __handle_sysrq(int key, bool check_mask)

+void __handle_sysrq(int key, unsigned int from)

 {

 	struct sysrq_key_op *op_p;

 	int orig_log_level;

@@ -544,11 +545,15 @@ void __handle_sysrq(int key, bool check_mask)

         op_p = __sysrq_get_key_op(key);

         if (op_p) {

+		/* Ban synthetic events from some sysrq functionality */

+		if ((from == SYSRQ_FROM_PROC || from == SYSRQ_FROM_SYNTHETIC) &&

+		    op_p->enable_mask & SYSRQ_DISABLE_USERSPACE)

+			printk("This sysrq operation is disabled from userspace.\n");

 		/*

 		 * Should we check for enabled operations (/proc/sysrq-trigger

 		 * should not) and is the invoked operation enabled?

 		 */

-		if (!check_mask || sysrq_on_mask(op_p->enable_mask)) {

+		if (from == SYSRQ_FROM_KERNEL || sysrq_on_mask(op_p->enable_mask)) {

 			pr_cont("%s\n", op_p->action_msg);

 			console_loglevel = orig_log_level;

 			op_p->handler(key);

@@ -580,7 +585,7 @@ void __handle_sysrq(int key, bool check_mask)

 void handle_sysrq(int key)

 {

 	if (sysrq_on())

-		__handle_sysrq(key, true);

+		__handle_sysrq(key, SYSRQ_FROM_KERNEL);

 }

 EXPORT_SYMBOL(handle_sysrq);

@@ -661,7 +666,7 @@ static void sysrq_do_reset(unsigned long _state)

 static void sysrq_handle_reset_request(struct sysrq_state *state)

 {

 	if (state->reset_requested)

-		__handle_sysrq(sysrq_xlate[KEY_B], false);

+		__handle_sysrq(sysrq_xlate[KEY_B], SYSRQ_FROM_KERNEL);

 	if (sysrq_reset_downtime_ms)

 		mod_timer(&state->keyreset_timer,

@@ -812,8 +817,10 @@ static bool sysrq_handle_keypress(struct sysrq_state *sysrq,

 	default:

 		if (sysrq->active && value && value != 2) {

+			int from = sysrq->handle.dev->flags & INPUTDEV_FLAGS_SYNTHETIC ?

+					SYSRQ_FROM_SYNTHETIC : 0;

 			sysrq->need_reinject = false;

-			__handle_sysrq(sysrq_xlate[code], true);

+			__handle_sysrq(sysrq_xlate[code], from);

 		}

 		break;

 	}

@@ -1097,7 +1104,7 @@ static ssize_t write_sysrq_trigger(struct file *file, const char __user *buf,

 		if (get_user(c, buf))

 			return -EFAULT;

-		__handle_sysrq(c, false);

+		__handle_sysrq(c, SYSRQ_FROM_PROC);

 	}

 	return count;

diff --git a/include/linux/input.h b/include/linux/input.h

index fb5e23c7ed98..9d2b45a21ade 100644

--- a/include/linux/input.h

+++ b/include/linux/input.h

@@ -42,6 +42,7 @@ struct input_value {

  * @phys: physical path to the device in the system hierarchy

  * @uniq: unique identification code for the device (if device has it)

  * @id: id of the device (struct input_id)

+ * @flags: input device flags (SYNTHETIC, etc.)

  * @propbit: bitmap of device properties and quirks

  * @evbit: bitmap of types of events supported by the device (EV_KEY,

  *	EV_REL, etc.)

@@ -124,6 +125,8 @@ struct input_dev {

 	const char *uniq;

 	struct input_id id;

+	unsigned int flags;

+

 	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

 	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];

@@ -190,6 +193,8 @@ struct input_dev {

 };

 #define to_input_dev(d) container_of(d, struct input_dev, dev)

+#define	INPUTDEV_FLAGS_SYNTHETIC	0x000000001

+

 /*

  * Verify that we are in sync with input_device_id mod_devicetable.h #defines

  */

diff --git a/include/linux/sysrq.h b/include/linux/sysrq.h

index 387fa7d05c98..f7c52a9ea394 100644

--- a/include/linux/sysrq.h

+++ b/include/linux/sysrq.h

@@ -28,6 +28,8 @@

 #define SYSRQ_ENABLE_BOOT	0x0080

 #define SYSRQ_ENABLE_RTNICE	0x0100

+#define SYSRQ_DISABLE_USERSPACE	0x00010000

+

 struct sysrq_key_op {

 	void (*handler)(int);

 	char *help_msg;

@@ -42,8 +44,12 @@ struct sysrq_key_op {

  * are available -- else NULL's).

  */

+#define SYSRQ_FROM_KERNEL	0x0001

+#define SYSRQ_FROM_PROC		0x0002

+#define SYSRQ_FROM_SYNTHETIC	0x0004

+

 void handle_sysrq(int key);

-void __handle_sysrq(int key, bool check_mask);

+void __handle_sysrq(int key, unsigned int from);

 int register_sysrq_key(int key, struct sysrq_key_op *op);

 int unregister_sysrq_key(int key, struct sysrq_key_op *op);

 struct sysrq_key_op *__sysrq_get_key_op(int key);

diff --git a/kernel/debug/kdb/kdb_main.c b/kernel/debug/kdb/kdb_main.c

index c8146d53ca67..b480cadf9272 100644

--- a/kernel/debug/kdb/kdb_main.c

+++ b/kernel/debug/kdb/kdb_main.c

@@ -1970,7 +1970,7 @@ static int kdb_sr(int argc, const char **argv)

 		return KDB_ARGCOUNT;

 	kdb_trap_printk++;

-	__handle_sysrq(*argv[1], check_mask);

+	__handle_sysrq(*argv[1], check_mask ? SYSRQ_FROM_KERNEL : 0);

 	kdb_trap_printk--;

 	return 0;

diff --git a/security/Kconfig b/security/Kconfig

index 8e01fd59ae7e..453cc89c198a 100644

--- a/security/Kconfig

+++ b/security/Kconfig

@@ -213,6 +213,14 @@ config LOCK_DOWN_KERNEL

 	  turns off various features that might otherwise allow access to the

 	  kernel image (eg. setting MSR registers).

+config ALLOW_LOCKDOWN_LIFT_BY_SYSRQ

+	bool "Allow the kernel lockdown to be lifted by SysRq"

+	depends on LOCK_DOWN_KERNEL && MAGIC_SYSRQ

+	help

+	  Allow the lockdown on a kernel to be lifted, by pressing a SysRq key

+	  combination on a wired keyboard.

+

+

 source security/selinux/Kconfig

 source security/smack/Kconfig

 source security/tomoyo/Kconfig

diff --git a/security/lock_down.c b/security/lock_down.c

index d8595c0e6673..2c6b00f0c229 100644

--- a/security/lock_down.c

+++ b/security/lock_down.c

@@ -11,8 +11,14 @@

 #include <linux/security.h>

 #include <linux/export.h>

+#include <linux/sysrq.h>

+#include <asm/setup.h>

+#ifdef CONFIG_ALLOW_LOCKDOWN_LIFT_BY_SYSRQ

+static __read_mostly bool kernel_locked_down;

+#else

 static __ro_after_init bool kernel_locked_down;

+#endif

 /*

  * Put the kernel into lock-down mode.

@@ -58,3 +64,44 @@ bool __kernel_is_locked_down(const char *what, bool first)

 	return kernel_locked_down;

 }

 EXPORT_SYMBOL(__kernel_is_locked_down);

+

+#ifdef CONFIG_ALLOW_LOCKDOWN_LIFT_BY_SYSRQ

+

+/*

+ * Take the kernel out of lockdown mode.

+ */

+static void lift_kernel_lockdown(void)

+{

+	pr_notice("Lifting lockdown\n");

+	kernel_locked_down = false;

+}

+

+/*

+ * Allow lockdown to be lifted by pressing something like SysRq+x (and not by

+ * echoing the appropriate letter into the sysrq-trigger file).

+ */

+static void sysrq_handle_lockdown_lift(int key)

+{

+	if (kernel_locked_down)

+		lift_kernel_lockdown();

+}

+

+static struct sysrq_key_op lockdown_lift_sysrq_op = {

+	.handler	= sysrq_handle_lockdown_lift,

+	.help_msg	= "unSB(x)",

+	.action_msg	= "Disabling Secure Boot restrictions",

+	.enable_mask	= SYSRQ_DISABLE_USERSPACE,

+};

+

+static int __init lockdown_lift_sysrq(void)

+{

+	if (kernel_locked_down) {

+		lockdown_lift_sysrq_op.help_msg[5] = LOCKDOWN_LIFT_KEY;

+		register_sysrq_key(LOCKDOWN_LIFT_KEY, &lockdown_lift_sysrq_op);

+	}

+	return 0;

+}

+

+late_initcall(lockdown_lift_sysrq);

+

+#endif /* CONFIG_ALLOW_LOCKDOWN_LIFT_BY_SYSRQ */

-- 

2.13.6

From 4c389db9daee3a3a444339a7d789de1d9366f736 Mon Sep 17 00:00:00 2001

From: David Howells <dhowells@redhat.com>

Date: Wed, 24 May 2017 14:56:01 +0100

Subject: [PATCH 03/26] Enforce module signatures if the kernel is locked down

If the kernel is locked down, require that all modules have valid

signatures that we can verify.

Signed-off-by: David Howells <dhowells@redhat.com>

Reviewed-by: "Lee, Chun-Yi" <jlee@suse.com>

Reviewed-by: James Morris <james.l.morris@oracle.com>

---

 kernel/module.c | 3 ++-

 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/kernel/module.c b/kernel/module.c

index de66ec825992..3d9a3270c179 100644

--- a/kernel/module.c

+++ b/kernel/module.c

@@ -2781,7 +2781,8 @@ static int module_sig_check(struct load_info *info, int flags)

 	}

 	/* Not having a signature is only an error if we're strict. */

-	if (err == -ENOKEY && !sig_enforce)

+	if (err == -ENOKEY && !sig_enforce &&

+	    !kernel_is_locked_down("Loading of unsigned modules"))

 		err = 0;

 	return err;

-- 

2.13.6

From 59312c44aa46939a14b3fbfeb510f94b4a73c8a1 Mon Sep 17 00:00:00 2001

From: Matthew Garrett <matthew.garrett@nebula.com>

Date: Wed, 24 May 2017 14:56:02 +0100

Subject: [PATCH 04/26] Restrict /dev/{mem,kmem,port} when the kernel is locked

 down

Allowing users to read and write to core kernel memory makes it possible

for the kernel to be subverted, avoiding module loading restrictions, and

also to steal cryptographic information.

Disallow /dev/mem and /dev/kmem from being opened this when the kernel has

been locked down to prevent this.

Also disallow /dev/port from being opened to prevent raw ioport access and

thus DMA from being used to accomplish the same thing.

Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>

Signed-off-by: David Howells <dhowells@redhat.com>

Reviewed-by: "Lee, Chun-Yi" <jlee@suse.com>

---

 drivers/char/mem.c | 2 ++

 1 file changed, 2 insertions(+)

diff --git a/drivers/char/mem.c b/drivers/char/mem.c

index 593a8818aca9..0ce5ac0a5c6b 100644

--- a/drivers/char/mem.c

+++ b/drivers/char/mem.c

@@ -762,6 +762,8 @@ static loff_t memory_lseek(struct file *file, loff_t offset, int orig)

 static int open_port(struct inode *inode, struct file *filp)

 {

+	if (kernel_is_locked_down("/dev/mem,kmem,port"))

+		return -EPERM;

 	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;

 }

-- 

2.13.6

From 6304f16efd61e66701f4b331e95da3cafb5f5f76 Mon Sep 17 00:00:00 2001

From: Matthew Garrett <matthew.garrett@nebula.com>

Date: Wed, 24 May 2017 14:56:02 +0100

Subject: [PATCH 05/26] kexec: Disable at runtime if the kernel is locked down

kexec permits the loading and execution of arbitrary code in ring 0, which

is something that lock-down is meant to prevent. It makes sense to disable

kexec in this situation.

This does not affect kexec_file_load() which can check for a signature on the

image to be booted.

Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>

Signed-off-by: David Howells <dhowells@redhat.com>

Acked-by: Dave Young <dyoung@redhat.com>

Reviewed-by: "Lee, Chun-Yi" <jlee@suse.com>

Reviewed-by: James Morris <james.l.morris@oracle.com>

cc: kexec@lists.infradead.org

---

 kernel/kexec.c | 7 +++++++

 1 file changed, 7 insertions(+)

diff --git a/kernel/kexec.c b/kernel/kexec.c

index e62ec4dc6620..7dadfed9b676 100644

--- a/kernel/kexec.c

+++ b/kernel/kexec.c

@@ -202,6 +202,13 @@ SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,

 		return -EPERM;

 	/*

+	 * kexec can be used to circumvent module loading restrictions, so

+	 * prevent loading in that case

+	 */

+	if (kernel_is_locked_down("kexec of unsigned images"))

+		return -EPERM;

+

+	/*

 	 * Verify we have a legal set of flags

 	 * This leaves us room for future extensions.

 	 */

-- 

2.13.6

From cd00079900870855cea3573253a95c331ccab523 Mon Sep 17 00:00:00 2001

From: Dave Young <dyoung@redhat.com>

Date: Wed, 24 May 2017 14:56:02 +0100

Subject: [PATCH 06/26] Copy secure_boot flag in boot params across kexec

 reboot

Kexec reboot in case secure boot being enabled does not keep the secure

boot mode in new kernel, so later one can load unsigned kernel via legacy

kexec_load.  In this state, the system is missing the protections provided

by secure boot.

Adding a patch to fix this by retain the secure_boot flag in original

kernel.

secure_boot flag in boot_params is set in EFI stub, but kexec bypasses the

stub.  Fixing this issue by copying secure_boot flag across kexec reboot.

Signed-off-by: Dave Young <dyoung@redhat.com>

Signed-off-by: David Howells <dhowells@redhat.com>

Reviewed-by: "Lee, Chun-Yi" <jlee@suse.com>

cc: kexec@lists.infradead.org

---

 arch/x86/kernel/kexec-bzimage64.c | 1 +

 1 file changed, 1 insertion(+)

diff --git a/arch/x86/kernel/kexec-bzimage64.c b/arch/x86/kernel/kexec-bzimage64.c

index fb095ba0c02f..7d0fac5bcbbe 100644

--- a/arch/x86/kernel/kexec-bzimage64.c

+++ b/arch/x86/kernel/kexec-bzimage64.c

@@ -179,6 +179,7 @@ setup_efi_state(struct boot_params *params, unsigned long params_load_addr,

 	if (efi_enabled(EFI_OLD_MEMMAP))

 		return 0;

+	params->secure_boot = boot_params.secure_boot;

 	ei->efi_loader_signature = current_ei->efi_loader_signature;

 	ei->efi_systab = current_ei->efi_systab;

 	ei->efi_systab_hi = current_ei->efi_systab_hi;

-- 

2.13.6

From de2ac5da82fc55156134820ba32095710b935ad5 Mon Sep 17 00:00:00 2001

From: Chun-Yi Lee <joeyli.kernel@gmail.com>

Date: Wed, 24 May 2017 14:56:03 +0100

Subject: [PATCH 07/26] kexec_file: Disable at runtime if the kernel is locked

 down

When KEXEC_VERIFY_SIG is not enabled, kernel should not load images

through kexec_file systemcall if the kernel is locked down.

This code was showed in Matthew's patch but not in git:

https://lkml.org/lkml/2015/3/13/778

Cc: Matthew Garrett <mjg59@srcf.ucam.org>

Signed-off-by: Chun-Yi Lee <jlee@suse.com>

Signed-off-by: David Howells <dhowells@redhat.com>

Reviewed-by: James Morris <james.l.morris@oracle.com>

cc: kexec@lists.infradead.org

---

 kernel/kexec_file.c | 7 +++++++

 1 file changed, 7 insertions(+)

diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c

index 9f48f4412297..ff6523f2dcc2 100644

--- a/kernel/kexec_file.c

+++ b/kernel/kexec_file.c

@@ -255,6 +255,13 @@ SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,

 	if (!capable(CAP_SYS_BOOT) || kexec_load_disabled)

 		return -EPERM;

+	/* Don't permit images to be loaded into trusted kernels if we're not

+	 * going to verify the signature on them

+	 */

+	if (!IS_ENABLED(CONFIG_KEXEC_VERIFY_SIG) &&

+	    kernel_is_locked_down("kexec of unsigned images"))

+		return -EPERM;

+

 	/* Make sure we have a legal set of flags */

 	if (flags != (flags & KEXEC_FILE_FLAGS))

 		return -EINVAL;

-- 

2.13.6

From ba823f2b5125605fcbac150fe27e622fd224ea61 Mon Sep 17 00:00:00 2001

From: Josh Boyer <jwboyer@fedoraproject.org>

Date: Wed, 24 May 2017 14:56:03 +0100

Subject: [PATCH 08/26] hibernate: Disable when the kernel is locked down

There is currently no way to verify the resume image when returning

from hibernate.  This might compromise the signed modules trust model,

so until we can work with signed hibernate images we disable it when the

kernel is locked down.

Signed-off-by: Josh Boyer <jwboyer@fedoraproject.org>

Signed-off-by: David Howells <dhowells@redhat.com>

Reviewed-by: "Lee, Chun-Yi" <jlee@suse.com>

cc: linux-pm@vger.kernel.org

---

 kernel/power/hibernate.c | 2 +-

 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c

index a5c36e9c56a6..f2eafefeec50 100644

--- a/kernel/power/hibernate.c

+++ b/kernel/power/hibernate.c

@@ -70,7 +70,7 @@ static const struct platform_hibernation_ops *hibernation_ops;

 bool hibernation_available(void)

 {

-	return (nohibernate == 0);

+	return nohibernate == 0 && !kernel_is_locked_down("Hibernation");

 }

 /**

-- 

2.13.6

From 9e78666a6153d72c3e50160a30ead699ba508d8f Mon Sep 17 00:00:00 2001

From: Matthew Garrett <mjg59@srcf.ucam.org>

Date: Wed, 24 May 2017 14:56:03 +0100

Subject: [PATCH 09/26] uswsusp: Disable when the kernel is locked down

uswsusp allows a user process to dump and then restore kernel state, which

makes it possible to modify the running kernel.  Disable this if the kernel

is locked down.

Signed-off-by: Matthew Garrett <mjg59@srcf.ucam.org>

Signed-off-by: David Howells <dhowells@redhat.com>

Reviewed-by: "Lee, Chun-Yi" <jlee@suse.com>

Reviewed-by: James Morris <james.l.morris@oracle.com>

cc: linux-pm@vger.kernel.org

---

 kernel/power/user.c | 3 +++

 1 file changed, 3 insertions(+)

diff --git a/kernel/power/user.c b/kernel/power/user.c

index 22df9f7ff672..678ade9decfe 100644

--- a/kernel/power/user.c

+++ b/kernel/power/user.c

@@ -52,6 +52,9 @@ static int snapshot_open(struct inode *inode, struct file *filp)

 	if (!hibernation_available())

 		return -EPERM;

+	if (kernel_is_locked_down("/dev/snapshot"))

+		return -EPERM;

+

 	lock_system_sleep();

 	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {

-- 

2.13.6