Lock down patches
Hi James,
David is low on cycles at the moment, so I'm taking over for this time round. This patchset introduces an optional kernel lockdown feature, intended to strengthen the boundary between UID 0 and the kernel. When enabled and active (by enabling the config option and passing the "lockdown" option on the kernel command line), various pieces of kernel functionality are restricted. Applications that rely on low-level access to either hardware or the kernel may cease working as a result - therefore this should not be enabled without appropriate evaluation beforehand.
The majority of mainstream distributions have been carrying variants of this patchset for many years now, so there's value in providing a unified upstream implementation to reduce the delta. This PR probably doesn't meet every distribution requirement, but gets us much closer to not requiring external patches.
This PR is mostly the same as the previous attempt, but with the following changes:
1) The integration between EFI secure boot and the lockdown state has been removed
2) A new CONFIG_KERNEL_LOCK_DOWN_FORCE kconfig option has been added, which will always enable lockdown regardless of the kernel command line
3) The integration with IMA has been dropped for now. Requiring the use of the IMA secure boot policy when lockdown is enabled isn't practical for most distributions at the moment, as there's still not a great deal of infrastructure for shipping packages with appropriate IMA signatures, and it makes it complicated for end users to manage custom IMA policies.
The following changes since commit a3b22b9f11d9fbc48b0291ea92259a5a810e9438:
Linux 5.0-rc7 (2019-02-17 18:46:40 -0800)
are available in the Git repository at:
https://github.com/mjg59/linux lock_down
for you to fetch changes up to 43e004ecae91bf9159b8e91cd1d613e58b8f63f8:
lockdown: Print current->comm in restriction messages (2019-02-28
11:19:23 -0800)
----------------------------------------------------------------
Dave Young (1):
Copy secure_boot flag in boot params across kexec reboot
David Howells (12):
Add the ability to lock down access to the running kernel image Enforce module signatures if the kernel is locked down Prohibit PCMCIA CIS storage when the kernel is locked down Lock down TIOCSSERIAL
Lock down module params that specify hardware parameters (eg. ioport) x86/mmiotrace: Lock down the testmmiotrace module
Lock down /proc/kcore
Lock down kprobes
bpf: Restrict kernel image access functions when the kernel is locked down Lock down perf
debugfs: Restrict debugfs when the kernel is locked down
lockdown: Print current->comm in restriction messages
Jiri Bohac (2):
kexec_file: split KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE
kexec_file: Restrict at runtime if the kernel is locked down
Josh Boyer (2):
hibernate: Disable when the kernel is locked down
acpi: Ignore acpi_rsdp kernel param when the kernel has been locked down
Kyle McMartin (1):
Add a SysRq option to lift kernel lockdown
Linn Crosetto (2):
acpi: Disable ACPI table override if the kernel is locked down
acpi: Disable APEI error injection if the kernel is locked down
Matthew Garrett (7):
Restrict /dev/{mem,kmem,port} when the kernel is locked down
kexec_load: Disable at runtime if the kernel is locked down
uswsusp: Disable when the kernel is locked down
PCI: Lock down BAR access when the kernel is locked down
x86: Lock down IO port access when the kernel is locked down x86/msr: Restrict MSR access when the kernel is locked down
ACPI: Limit access to custom_method when the kernel is locked down
arch/x86/Kconfig | 20 ++++++++++++----- arch/x86/include/asm/setup.h | 2 ++ arch/x86/kernel/ioport.c | 6 ++++-- arch/x86/kernel/kexec-bzimage64.c | 1 + arch/x86/kernel/msr.c | 10 +++++++++ arch/x86/mm/testmmiotrace.c | 3 +++ crypto/asymmetric_keys/verify_pefile.c | 4 +++- drivers/acpi/apei/einj.c | 3 +++ drivers/acpi/custom_method.c | 3 +++ drivers/acpi/osl.c | 2 +- drivers/acpi/tables.c | 5 +++++ drivers/char/mem.c | 2 ++ drivers/input/misc/uinput.c | 1 + drivers/pci/pci-sysfs.c | 9 ++++++++ drivers/pci/proc.c | 9 +++++++- drivers/pci/syscall.c | 3 ++- drivers/pcmcia/cistpl.c | 3 +++ drivers/tty/serial/serial_core.c | 6 ++++++ drivers/tty/sysrq.c | 19 +++++++++++------ fs/debugfs/file.c | 28 ++++++++++++++++++++++++ fs/debugfs/inode.c | 30 ++++++++++++++++++++++++-- fs/proc/kcore.c | 2 ++ include/linux/ima.h | 6 ++++++ include/linux/input.h | 5 +++++ include/linux/kernel.h | 17 +++++++++++++++ include/linux/kexec.h | 4 ++-- include/linux/security.h | 9 +++++++- include/linux/sysrq.h | 8 ++++++- kernel/bpf/syscall.c | 3 +++ kernel/debug/kdb/kdb_main.c | 2 +- kernel/events/core.c | 5 +++++ kernel/kexec.c | 7 ++++++ kernel/kexec_file.c | 56 ++++++++++++++++++++++++++++++++++++++++++------ kernel/kprobes.c | 3 +++ kernel/module.c | 56 ++++++++++++++++++++++++++++++++++++------------ kernel/params.c | 26 ++++++++++++++++++----- kernel/power/hibernate.c | 2 +- kernel/power/user.c | 3 +++ security/Kconfig | 24 +++++++++++++++++++++ security/Makefile | 3 +++ security/lock_down.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 41 files changed, 466 insertions(+), 50 deletions(-) create mode 100644 security/lock_down.c
Quoted 12 lines · Matthew Garrett
Hi James,
David is low on cycles at the moment, so I'm taking over for this time round. This patchset introduces an optional kernel lockdown feature, intended to strengthen the boundary between UID 0 and the kernel. When enabled and active (by enabling the config option and passing the "lockdown" option on the kernel command line), various pieces of kernel functionality are restricted. Applications that rely on low-level access to either hardware or the kernel may cease working as a result - therefore this should not be enabled without appropriate evaluation beforehand.
Quoted 8 lines
The majority of mainstream distributions have been carrying variants of this patchset for many years now, so there's value in providing a unified upstream implementation to reduce the delta. This PR probably doesn't meet every distribution requirement, but gets us much closer to not requiring external patches.
This PR is mostly the same as the previous attempt, but with the following changes:
Where/when was this latest version of the patches posted?
Quoted 12 lines
1) The integration between EFI secure boot and the lockdown state has been removed
2) A newCONFIG_KERNEL_LOCK_DOWN_FORCEkconfig option has been added, which will always enable lockdown regardless of the kernel command line
3) The integration with IMA has been dropped for now. Requiring the use of the IMA secure boot policy when lockdown is enabled isn't practical for most distributions at the moment, as there's still not a great deal of infrastructure for shipping packages with appropriate IMA signatures, and it makes it complicated for end users to manage custom IMA policies.
I'm all in favor of dropping the original attempt to coordinate between the kexec PE and IMA kernel image signatures and the kernel appended and IMA modules signatures, but there has been quite a bit of work recently coordinating the different types of signatures.
Preventing systems which do use IMA for signature verification, should not limit their ability to enable "lock down". Does this version of the "lock down" patches coordinate the different kexec kernel image and kernel module signature verification methods?
Mimi
Quoted 5 lines · Mimi Zohar
Quoted 2 lines · Matthew Garrett
This PR is mostly the same as the previous attempt, but with the following changes:
Where/when was this latest version of the patches posted?
They should have followed this, but git-send-email choked on some
reviewed-by: lines so I'm just trying to sort that out.
Quoted 18 lines
Quoted 12 lines
1) The integration between EFI secure boot and the lockdown state has been removed
2) A newCONFIG_KERNEL_LOCK_DOWN_FORCEkconfig option has been added, which will always enable lockdown regardless of the kernel command line
3) The integration with IMA has been dropped for now. Requiring the use of the IMA secure boot policy when lockdown is enabled isn't practical for most distributions at the moment, as there's still not a great deal of infrastructure for shipping packages with appropriate IMA signatures, and it makes it complicated for end users to manage custom IMA policies.I'm all in favor of dropping the original attempt to coordinate between the kexec PE and IMA kernel image signatures and the kernel appended and IMA modules signatures, but there has been quite a bit of work recently coordinating the different types of signatures.
Quoted 4 lines
Preventing systems which do use IMA for signature verification, should not limit their ability to enable "lock down". Does this version of the "lock down" patches coordinate the different kexec kernel image and kernel module signature verification methods?
It's a little more complicated than this. We can't just rely on IMA appraisal - it has to be based on digital signatures, and the existing patch only made that implicit by enabling the secure_boot policy. I think we do want to integrate these, but there's a few things we need to take into account:
1) An integrated solution can't depend on xattrs, both because of the lagging support for distributing those signatures but also because we need to support filesystems that don't support xattrs
2) An integrated solution can't depend on the current secure_boot policy because that requires signed IMA policy updates, but distributions have no way of knowing what IMA policy end users require
In any case, I do agree that we should aim to make this more reasonable - having orthogonal signing code doesn't benefit anyone. Once there's solid agreement on that we can extend this support.
Quoted 9 lines · Matthew Garrett
Quoted 5 lines · Mimi Zohar
Quoted 2 lines · Matthew Garrett
This PR is mostly the same as the previous attempt, but with the following changes:
Where/when was this latest version of the patches posted?
They should have followed this, but git-send-email choked on some
reviewed-by: lines so I'm just trying to sort that out.
I'm a little perplexed as to why you would send a pull request, before re-posting the patches with the changes for review.
Quoted 19 lines
Quoted 19 lines
Quoted 13 lines
1) The integration between EFI secure boot and the lockdown state has been removed
2) A newCONFIG_KERNEL_LOCK_DOWN_FORCEkconfig option has been added, which will always enable lockdown regardless of the kernel command line
3) The integration with IMA has been dropped for now. Requiring the use of the IMA secure boot policy when lockdown is enabled isn't practical for most distributions at the moment, as there's still not a great deal of infrastructure for shipping packages with appropriate IMA signatures, and it makes it complicated for end users to manage custom IMA policies.I'm all in favor of dropping the original attempt to coordinate between the kexec PE and IMA kernel image signatures and the kernel appended and IMA modules signatures, but there has been quite a bit of work recently coordinating the different types of signatures.
Quoted 8 lines
Quoted 4 lines
Preventing systems which do use IMA for signature verification, should not limit their ability to enable "lock down". Does this version of the "lock down" patches coordinate the different kexec kernel image and kernel module signature verification methods?
It's a little more complicated than this. We can't just rely on IMA appraisal - it has to be based on digital signatures, and the existing patch only made that implicit by enabling the
secure_bootpolicy.
Right, which is the reason the IMA architecture specific policy requires file signatures. [1][2]
Quoted 7 lines
I
think we do want to integrate these, but there's a few things we need to take into account:1) An integrated solution can't depend on xattrs, both because of the lagging support for distributing those signatures but also because we need to support filesystems that don't support xattrs
That's not a valid reason for preventing systems that do use IMA for verifying the kexec kernel image signature or kernel module signatures from enabling "lock down". This just means that there needs to be some coordination between the different signature verification methods. [1][2]
Quoted 3 lines
2) An integrated solution can't depend on the current
secure_bootpolicy because that requires signed IMA policy updates, but distributions have no way of knowing what IMA policy end users require
Both the "CONFIG_IMA_APPRAISE_REQUIRE_KEXEC_SIGS" and the IMA architecture policy rules persist after loading a custom policy. Neither of them require loading or signing a custom policy.
Quoted 4 lines
In any case, I do agree that we should aim to make this more reasonable - having orthogonal signing code doesn't benefit anyone. Once there's solid agreement on that we can extend this support.
Having multiple signature verification methods is going to be around for a while. The solution is to coordinate the signature verification methods, without requiring both types of signatures. [1][2]
[For distros that do enable IMA, enabling the IMA architecture specific policy enforces the kexec kernel image and kernel modules signature verification.]
Mimi
[1] Subject: [PATCH v2 0/5] selftests/ima: add kexec and kernel module tests
[2] Patches available from the "next-queued-testing" branch
https://git.kernel.org/pub/scm/linux/kernel/git/zohar/linux-integrity.git/
Quoted 10 lines · Mimi Zohar
Quoted 5 lines · Matthew Garrett
Quoted 1 line · Mimi Zohar
Where/when was this latest version of the patches posted?
They should have followed this, but git-send-email choked on some
reviewed-by: lines so I'm just trying to sort that out.I'm a little perplexed as to why you would send a pull request, before re-posting the patches with the changes for review.
They should be there now. There's no substantive change to the patches, other than having dropped a few from the series.
Quoted 6 lines
Quoted 3 lines
It's a little more complicated than this. We can't just rely on IMA appraisal - it has to be based on digital signatures, and the existing patch only made that implicit by enabling the
secure_bootpolicy.Right, which is the reason the IMA architecture specific policy requires file signatures. [1][2]
The current patches seem to require ima signatures - shouldn't this allow ima digests as long as there's an evm signature?
Quoted 8 lines
Quoted 7 lines
I
think we do want to integrate these, but there's a few things we need to take into account:1) An integrated solution can't depend on xattrs, both because of the lagging support for distributing those signatures but also because we need to support filesystems that don't support xattrs
Quoted 5 lines
That's not a valid reason for preventing systems that do use IMA for verifying the kexec kernel image signature or kernel module signatures from enabling "lock down". This just means that there needs to be some coordination between the different signature verification methods. [1][2]
I agree, but the current form of the integration makes it impossible for anyone using an IMA-enabled kernel (but not using IMA) to do anything unless they have IMA signatures. It's a problem we need to solve, I just don't think it's a problem we need to solve before merging the patchset.
Quoted 7 lines
Quoted 3 lines
2) An integrated solution can't depend on the current
secure_bootpolicy because that requires signed IMA policy updates, but distributions have no way of knowing what IMA policy end users requireBoth the "
CONFIG_IMA_APPRAISE_REQUIRE_KEXEC_SIGS" and the IMA architecture policy rules persist after loading a custom policy.
Neither of them require loading or signing a custom policy.
The previous version of the lockdown patchset sets the secure_boot policy when lockdown is enabled, which does require that any custom policy be signed.
Quoted 8 lines
Quoted 4 lines
In any case, I do agree that we should aim to make this more reasonable - having orthogonal signing code doesn't benefit anyone. Once there's solid agreement on that we can extend this support.
Having multiple signature verification methods is going to be around for a while. The solution is to coordinate the signature verification methods, without requiring both types of signatures. [1][2]
Agree, and once we have a solution to this we should integrate that with lockdown. I don't think merging this first makes that any harder. Importantly, this version of the patchset doesn't enable lockdown automatically unless explicitly configured to do so, which means you can build a lockdown kernel without interfering with IMA.
Quoted 11 lines · Matthew Garrett
Quoted 5 lines
That's not a valid reason for preventing systems that do use IMA for verifying the kexec kernel image signature or kernel module signatures from enabling "lock down". This just means that there needs to be some coordination between the different signature verification methods. [1][2]
I agree, but the current form of the integration makes it impossible for anyone using an IMA-enabled kernel (but not using IMA) to do anything unless they have IMA signatures. It's a problem we need to solve, I just don't think it's a problem we need to solve before merging the patchset.
That's simply not true. Have you even looked at the IMA architecture patches?
fcf338449af5 x86/ima: require signed kernel modules d958083a8f64 x86/ima: define arch_get_ima_policy() for x86
Mimi
Quoted 9 lines · Mimi Zohar
Quoted 6 lines · Matthew Garrett
Quoted 5 lines
That's not a valid reason for preventing systems that do use IMA for verifying the kexec kernel image signature or kernel module signatures from enabling "lock down". This just means that there needs to be some coordination between the different signature verification methods. [1][2]
Quoted 8 lines
Quoted 5 lines
I agree, but the current form of the integration makes it impossible for anyone using an IMA-enabled kernel (but not using IMA) to do anything unless they have IMA signatures. It's a problem we need to solve, I just don't think it's a problem we need to solve before merging the patchset.
That's simply not true. Have you even looked at the IMA architecture patches?
Sorry, I think we're talking at cross purposes - I was referring to your patch "ima: require secure_boot rules in lockdown mode"
(https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/commit/?h=efi-lock-down&id=7fa3734bd31a4b3fe71358fcba8d4878e5005b7f).
If the goal is just to use the architecture rules then I don't see any conflict, and as far as I can tell things would just work as is if I drop the ima portion from "kexec_file: Restrict at runtime if the kernel is locked down"? Apologies, I'd thought that the secure_boot ruleset was still intended to be used in a lockdown environment.
Quoted 16 lines · Matthew Garrett
Quoted 15 lines · Mimi Zohar
Quoted 11 lines · Matthew Garrett
Quoted 5 lines
That's not a valid reason for preventing systems that do use IMA for verifying the kexec kernel image signature or kernel module signatures from enabling "lock down". This just means that there needs to be some coordination between the different signature verification methods. [1][2]
I agree, but the current form of the integration makes it impossible for anyone using an IMA-enabled kernel (but not using IMA) to do anything unless they have IMA signatures. It's a problem we need to solve, I just don't think it's a problem we need to solve before merging the patchset.
Quoted 6 lines
Quoted 2 lines
That's simply not true. Have you even looked at the IMA architecture patches?
Sorry, I think we're talking at cross purposes - I was referring to your patch "ima: require
secure_bootrules in lockdown mode"
(https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/commit/?h=efi-lock-down&id=7fa3734bd31a4b3fe71358fcba8d4878e5005b7f).
With the "secure_boot" rules it was difficult to coordinate the different signature verification methods. Plus they weren't persistent after loading a custom policy.
Quoted 2 lines
If the goal is just to use the architecture rules then I don't see any conflict,
yes
Quoted 3 lines
and as far as I can tell things would just work as is if I drop the ima portion from "
kexec_file: Restrict at runtime if the kernel is locked down"?
That code is a remnant left over from when the "secure_boot" policy was enabled. However, dropping the IMA portion there would result in allowing only PE signed kernel images. (On Power, for example, there aren't any PE signatures.)
My suggestion would be to drop this patch and require the architecture specific policy in "lock down" mode.
Quoted 2 lines
Apologies, I'd thought that the
secure_boot
ruleset was still intended to be used in a lockdown environment.
No, not any longer.
Mimi
PATCH 1/27 Add the ability to lock down access to the running kernel image
In reply to Matthew GarrettFrom: David Howells <[email protected]>
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.
--- include/linux/kernel.h | 17 ++++++++++++ include/linux/security.h | 9 +++++- security/Kconfig | 15 ++++++++++ security/Makefile | 3 ++ security/lock_down.c | 59 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 security/lock_down.c
include/linux/kernel.h +17 -0
@@ -340,6 +340,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);
include/linux/security.h +8 -1
@@ -1793,5 +1793,12 @@ static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)#endif /* CONFIG_SECURITY */ #endif /* CONFIG_BPF_SYSCALL */ -#endif /* ! __LINUX_SECURITY_H */ +#ifdef CONFIG_LOCK_DOWN_KERNEL +extern void __init init_lockdown (void ); +#else +static inline void __init init_lockdown (void ) +{ +} +#endif +#endif /* ! __LINUX_SECURITY_H */
security/Kconfig +15 -0
@@ -230,6 +230,21 @@ 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. If lockdown support is enabled + and activated, the kernel will impose additional restrictions + intended to prevent uid 0 from being able to modify the running + kernel. This may break userland applications that rely on low-level + access to hardware. + +config LOCK_DOWN_KERNEL_FORCE + bool "Enable kernel lockdown mode automatically" + depends on LOCK_DOWN_KERNEL + help + Enable the kernel lock down functionality automatically at boot. + source "security/selinux/Kconfig" source "security/smack/Kconfig" source "security/tomoyo/Kconfig"
security/Makefile +3 -0
@@ -30,3 +30,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
security/lock_down.c new file +59 -0
59 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 2/27 Add a SysRq option to lift kernel lockdown
From: Kyle McMartin <[email protected]>
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 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. Since this macro must be defined in an arch to be able to use this facility for that arch, the Kconfig option is restricted to arches that support it.
--- 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 | 9 +++++++ security/lock_down.c | 47 ++++++++++++++++++++++++++++++++++++ 8 files changed, 85 insertions(+), 8 deletions(-)
arch/x86/include/asm/setup.h +2 -0
@@ -9,6 +9,8 @@#include <linux/linkage.h> #include <asm/page_types.h> +#define LOCKDOWN_LIFT_KEY 'x' +#ifdef __i386__#include <linux/pfn.h>
drivers/input/misc/uinput.c +1 -0
@@ -366,6 +366,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);
drivers/tty/sysrq.c +13 -6
@@ -480,6 +480,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 */
@@ -523,7 +524,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;
@@ -543,11 +544,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);
@@ -579,7 +584,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);
@@ -659,7 +664,7 @@ static void sysrq_do_reset(struct timer_list *t)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 ; }
@@ -1096,7 +1103,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;
include/linux/input.h +5 -0
@@ -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 */
include/linux/sysrq.h +7 -1
@@ -29,6 +29,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;
@@ -43,8 +45,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);
kernel/debug/kdb/kdb_main.c +1 -1
@@ -1981,7 +1981,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 ;
security/Kconfig +9 -0
@@ -245,6 +245,15 @@ config LOCK_DOWN_KERNEL_FORCE help Enable the kernel lock down functionality automatically at boot. +config ALLOW_LOCKDOWN_LIFT_BY_SYSRQ + bool "Allow the kernel lockdown to be lifted by SysRq" + depends on LOCK_DOWN_KERNEL + depends on MAGIC_SYSRQ + depends on X86 + 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"
security/lock_down.c +47 -0
58 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 1/27 Add the ability to lock down access to the running kernel image
In reply to Matthew GarrettFrom: David Howells <[email protected]>
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.
--- include/linux/kernel.h | 17 ++++++++++++ include/linux/security.h | 9 +++++- security/Kconfig | 15 ++++++++++ security/Makefile | 3 ++ security/lock_down.c | 59 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 security/lock_down.c
include/linux/kernel.h +17 -0
@@ -340,6 +340,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);
include/linux/security.h +8 -1
@@ -1793,5 +1793,12 @@ static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)#endif /* CONFIG_SECURITY */ #endif /* CONFIG_BPF_SYSCALL */ -#endif /* ! __LINUX_SECURITY_H */ +#ifdef CONFIG_LOCK_DOWN_KERNEL +extern void __init init_lockdown (void ); +#else +static inline void __init init_lockdown (void ) +{ +} +#endif +#endif /* ! __LINUX_SECURITY_H */
security/Kconfig +15 -0
@@ -230,6 +230,21 @@ 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. If lockdown support is enabled + and activated, the kernel will impose additional restrictions + intended to prevent uid 0 from being able to modify the running + kernel. This may break userland applications that rely on low-level + access to hardware. + +config LOCK_DOWN_KERNEL_FORCE + bool "Enable kernel lockdown mode automatically" + depends on LOCK_DOWN_KERNEL + help + Enable the kernel lock down functionality automatically at boot. + source "security/selinux/Kconfig" source "security/smack/Kconfig" source "security/tomoyo/Kconfig"
security/Makefile +3 -0
@@ -30,3 +30,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
security/lock_down.c new file +59 -0
59 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 2/27 Add a SysRq option to lift kernel lockdown
From: Kyle McMartin <[email protected]>
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 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. Since this macro must be defined in an arch to be able to use this facility for that arch, the Kconfig option is restricted to arches that support it.
--- 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 | 9 +++++++ security/lock_down.c | 47 ++++++++++++++++++++++++++++++++++++ 8 files changed, 85 insertions(+), 8 deletions(-)
arch/x86/include/asm/setup.h +2 -0
@@ -9,6 +9,8 @@#include <linux/linkage.h> #include <asm/page_types.h> +#define LOCKDOWN_LIFT_KEY 'x' +#ifdef __i386__#include <linux/pfn.h>
drivers/input/misc/uinput.c +1 -0
@@ -366,6 +366,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);
drivers/tty/sysrq.c +13 -6
@@ -480,6 +480,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 */
@@ -523,7 +524,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;
@@ -543,11 +544,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);
@@ -579,7 +584,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);
@@ -659,7 +664,7 @@ static void sysrq_do_reset(struct timer_list *t)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 ; }
@@ -1096,7 +1103,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;
include/linux/input.h +5 -0
@@ -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 */
include/linux/sysrq.h +7 -1
@@ -29,6 +29,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;
@@ -43,8 +45,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);
kernel/debug/kdb/kdb_main.c +1 -1
@@ -1981,7 +1981,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 ;
security/Kconfig +9 -0
@@ -245,6 +245,15 @@ config LOCK_DOWN_KERNEL_FORCE help Enable the kernel lock down functionality automatically at boot. +config ALLOW_LOCKDOWN_LIFT_BY_SYSRQ + bool "Allow the kernel lockdown to be lifted by SysRq" + depends on LOCK_DOWN_KERNEL + depends on MAGIC_SYSRQ + depends on X86 + 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"
security/lock_down.c +47 -0
58 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 1/27 Add the ability to lock down access to the running kernel image
In reply to Matthew GarrettFrom: David Howells <[email protected]>
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.
--- include/linux/kernel.h | 17 ++++++++++++ include/linux/security.h | 9 +++++- security/Kconfig | 15 ++++++++++ security/Makefile | 3 ++ security/lock_down.c | 59 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 security/lock_down.c
include/linux/kernel.h +17 -0
@@ -340,6 +340,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);
include/linux/security.h +8 -1
@@ -1793,5 +1793,12 @@ static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)#endif /* CONFIG_SECURITY */ #endif /* CONFIG_BPF_SYSCALL */ -#endif /* ! __LINUX_SECURITY_H */ +#ifdef CONFIG_LOCK_DOWN_KERNEL +extern void __init init_lockdown (void ); +#else +static inline void __init init_lockdown (void ) +{ +} +#endif +#endif /* ! __LINUX_SECURITY_H */
security/Kconfig +15 -0
@@ -230,6 +230,21 @@ 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. If lockdown support is enabled + and activated, the kernel will impose additional restrictions + intended to prevent uid 0 from being able to modify the running + kernel. This may break userland applications that rely on low-level + access to hardware. + +config LOCK_DOWN_KERNEL_FORCE + bool "Enable kernel lockdown mode automatically" + depends on LOCK_DOWN_KERNEL + help + Enable the kernel lock down functionality automatically at boot. + source "security/selinux/Kconfig" source "security/smack/Kconfig" source "security/tomoyo/Kconfig"
security/Makefile +3 -0
@@ -30,3 +30,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
security/lock_down.c new file +59 -0
59 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 2/27 Add a SysRq option to lift kernel lockdown
From: Kyle McMartin <[email protected]>
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 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. Since this macro must be defined in an arch to be able to use this facility for that arch, the Kconfig option is restricted to arches that support it.
--- 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 | 9 +++++++ security/lock_down.c | 47 ++++++++++++++++++++++++++++++++++++ 8 files changed, 85 insertions(+), 8 deletions(-)
arch/x86/include/asm/setup.h +2 -0
@@ -9,6 +9,8 @@#include <linux/linkage.h> #include <asm/page_types.h> +#define LOCKDOWN_LIFT_KEY 'x' +#ifdef __i386__#include <linux/pfn.h>
drivers/input/misc/uinput.c +1 -0
@@ -366,6 +366,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);
drivers/tty/sysrq.c +13 -6
@@ -480,6 +480,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 */
@@ -523,7 +524,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;
@@ -543,11 +544,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);
@@ -579,7 +584,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);
@@ -659,7 +664,7 @@ static void sysrq_do_reset(struct timer_list *t)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 ; }
@@ -1096,7 +1103,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;
include/linux/input.h +5 -0
@@ -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 */
include/linux/sysrq.h +7 -1
@@ -29,6 +29,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;
@@ -43,8 +45,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);
kernel/debug/kdb/kdb_main.c +1 -1
@@ -1981,7 +1981,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 ;
security/Kconfig +9 -0
@@ -245,6 +245,15 @@ config LOCK_DOWN_KERNEL_FORCE help Enable the kernel lock down functionality automatically at boot. +config ALLOW_LOCKDOWN_LIFT_BY_SYSRQ + bool "Allow the kernel lockdown to be lifted by SysRq" + depends on LOCK_DOWN_KERNEL + depends on MAGIC_SYSRQ + depends on X86 + 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"
security/lock_down.c +47 -0
58 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 1/27 Add the ability to lock down access to the running kernel image
In reply to Matthew GarrettFrom: David Howells <[email protected]>
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.
--- include/linux/kernel.h | 17 ++++++++++++ include/linux/security.h | 9 +++++- security/Kconfig | 15 ++++++++++ security/Makefile | 3 ++ security/lock_down.c | 59 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 security/lock_down.c
include/linux/kernel.h +17 -0
@@ -340,6 +340,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);
include/linux/security.h +8 -1
@@ -1793,5 +1793,12 @@ static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)#endif /* CONFIG_SECURITY */ #endif /* CONFIG_BPF_SYSCALL */ -#endif /* ! __LINUX_SECURITY_H */ +#ifdef CONFIG_LOCK_DOWN_KERNEL +extern void __init init_lockdown (void ); +#else +static inline void __init init_lockdown (void ) +{ +} +#endif +#endif /* ! __LINUX_SECURITY_H */
security/Kconfig +15 -0
@@ -230,6 +230,21 @@ 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. If lockdown support is enabled + and activated, the kernel will impose additional restrictions + intended to prevent uid 0 from being able to modify the running + kernel. This may break userland applications that rely on low-level + access to hardware. + +config LOCK_DOWN_KERNEL_FORCE + bool "Enable kernel lockdown mode automatically" + depends on LOCK_DOWN_KERNEL + help + Enable the kernel lock down functionality automatically at boot. + source "security/selinux/Kconfig" source "security/smack/Kconfig" source "security/tomoyo/Kconfig"
security/Makefile +3 -0
@@ -30,3 +30,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
security/lock_down.c new file +59 -0
59 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 2/27 Add a SysRq option to lift kernel lockdown
From: Kyle McMartin <[email protected]>
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 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. Since this macro must be defined in an arch to be able to use this facility for that arch, the Kconfig option is restricted to arches that support it.
--- 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 | 9 +++++++ security/lock_down.c | 47 ++++++++++++++++++++++++++++++++++++ 8 files changed, 85 insertions(+), 8 deletions(-)
arch/x86/include/asm/setup.h +2 -0
@@ -9,6 +9,8 @@#include <linux/linkage.h> #include <asm/page_types.h> +#define LOCKDOWN_LIFT_KEY 'x' +#ifdef __i386__#include <linux/pfn.h>
drivers/input/misc/uinput.c +1 -0
@@ -366,6 +366,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);
drivers/tty/sysrq.c +13 -6
@@ -480,6 +480,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 */
@@ -523,7 +524,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;
@@ -543,11 +544,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);
@@ -579,7 +584,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);
@@ -659,7 +664,7 @@ static void sysrq_do_reset(struct timer_list *t)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 ; }
@@ -1096,7 +1103,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;
include/linux/input.h +5 -0
@@ -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 */
include/linux/sysrq.h +7 -1
@@ -29,6 +29,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;
@@ -43,8 +45,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);
kernel/debug/kdb/kdb_main.c +1 -1
@@ -1981,7 +1981,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 ;
security/Kconfig +9 -0
@@ -245,6 +245,15 @@ config LOCK_DOWN_KERNEL_FORCE help Enable the kernel lock down functionality automatically at boot. +config ALLOW_LOCKDOWN_LIFT_BY_SYSRQ + bool "Allow the kernel lockdown to be lifted by SysRq" + depends on LOCK_DOWN_KERNEL + depends on MAGIC_SYSRQ + depends on X86 + 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"
security/lock_down.c +47 -0
58 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 3/27 Enforce module signatures if the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
If the kernel is locked down, require that all modules have valid signatures that we can verify or that IMA can validate the file.
I have adjusted the errors generated:
(1) If there's no signature (ENODATA) or we can't check it (ENOPKG, ENOKEY), then:
(a) If signatures are enforced then EKEYREJECTED is returned.
(b) If IMA will have validated the image, return 0 (okay).
(c) If there's no signature or we can't check it, but the kernel is locked down then EPERM is returned (this is then consistent with other lockdown cases).
(2) If the signature is unparseable (EBADMSG, EINVAL), the signature fails the check (EKEYREJECTED) or a system error occurs (eg. ENOMEM), we return the error we got.
Note that the X.509 code doesn't check for key expiry as the RTC might not be valid or might not have been transferred to the kernel's clock yet.
--- kernel/module.c | 56 +++++++++++++++++++++++++++++++++++++------------ 1 file changed, 43 insertions(+), 13 deletions(-)
kernel/module.c +43 -13
@@ -64,6 +64,7 @@#include <linux/bsearch.h> #include <linux/dynamic_debug.h> #include <linux/audit.h> +#include <linux/ima.h> #include <uapi/linux/module.h> #include "module-internal.h"
@@ -2765,10 +2766,12 @@ static inline void kmemleak_load_module(const struct module *mod,#endif #ifdef CONFIG_MODULE_SIG -static int module_sig_check (struct load_info *info,int flags) +static int module_sig_check (struct load_info *info,int flags, +bool can_do_ima_check) { -int err = -ENOKEY ; +int err = -ENODATA ;const unsigned long markerlen =sizeof (MODULE_SIG_STRING ) -1 ; +const char *reason;const void *mod = info->hdr;/*
@@ -2783,19 +2786,46 @@ static int module_sig_check(struct load_info *info, int flags) err = mod_verify_sig(mod, info); } -if (!err) { +switch (err) { +case 0 : info->sig_ok = true;return 0 ; - } -/* Not having a signature is only an error if we're strict. */ -if (err == -ENOKEY && !is_module_sig_enforced ()) - err =0 ; +/* We don't permit modules to be loaded into trusted kernels +* without a valid signature on them, but if we're not +* enforcing, certain errors are non-fatal. +*/ +case -ENODATA : + reason ="Loading of unsigned module" ; + goto decide; +case -ENOPKG : + reason ="Loading of module with unsupported crypto" ; + goto decide; +case -ENOKEY : + reason ="Loading of module with unavailable key" ; + decide: +if (is_module_sig_enforced ()) { +pr_notice ("%s is rejected\n" , reason); +return -EKEYREJECTED ; + } -return err; +if (can_do_ima_check &&is_ima_appraise_enabled ()) +return 0 ; +if (kernel_is_locked_down (reason)) +return -EPERM ; +return 0 ; + +/* All other errors are fatal, including nomem, unparseable +* signatures and signature check failures - even if signatures +* aren't required. +*/ +default : +return err; + } }#else /* !CONFIG_MODULE_SIG */ -static int module_sig_check (struct load_info *info,int flags) +static int module_sig_check (struct load_info *info,int flags, +bool can_do_ima_check) {return 0 ; }
@@ -3658,7 +3688,7 @@ static int unknown_module_param_cb(char *param, char *val, const char *modname,/* Allocate and load the module: note that size of section 0 is always zero, and we rely on this for optional sections. */ static int load_module (struct load_info *info,const char __user *uargs, -int flags) +int flags,bool can_do_ima_check) {struct module *mod;long err =0 ;
@@ -3677,7 +3707,7 @@ static int load_module(struct load_info *info, const char __user *uargs, goto free_copy; } - err =module_sig_check (info, flags); + err =module_sig_check (info, flags, can_do_ima_check);if (err) goto free_copy;
@@ -3872,7 +3902,7 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,if (err)return err; -return load_module (&info, uargs,0 ); +return load_module (&info, uargs,0 , false); } SYSCALL_DEFINE3(finit_module, int, fd, const char __user *, uargs, int, flags)
@@ -3899,7 +3929,7 @@ SYSCALL_DEFINE3(finit_module, int, fd, const char __user *, uargs, int, flags) info.hdr = hdr; info.len = size; -return load_module (&info, uargs, flags); +return load_module (&info, uargs, flags, true); }static inline int within (unsigned long addr,void *start,unsigned long size)
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 4/27 Restrict /dev/{mem,kmem,port} when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
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.
--- drivers/char/mem.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/char/mem.c +2 -0
@@ -786,6 +786,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 ; }
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 5/27 kexec_load: Disable at runtime if the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
The kexec_load() syscall 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_load() in this situation.
This does not affect kexec_file_load() syscall which can check for a signature on the image to be booted.
--- kernel/kexec.c | 7 +++++++ 1 file changed, 7 insertions(+)
kernel/kexec.c +7 -0
@@ -207,6 +207,13 @@ static inline int kexec_load_check(unsigned long nr_segments,if (result <0 )return result; +/* +* 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.
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 6/27 Copy secure_boot flag in boot params across kexec reboot
In reply to Matthew GarrettFrom: Dave Young <[email protected]>
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.
--- arch/x86/kernel/kexec-bzimage64.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/kernel/kexec-bzimage64.c +1 -0
@@ -182,6 +182,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;
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 7/27 kexec_file: split KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE
In reply to Matthew GarrettFrom: Jiri Bohac <[email protected]>
This is a preparatory patch for kexec_file_load() lockdown. A locked down kernel needs to prevent unsigned kernel images from being loaded with kexec_file_load(). Currently, the only way to force the signature verification is compiling with KEXEC_VERIFY_SIG. This prevents loading usigned images even when the kernel is not locked down at runtime.
This patch splits KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE. Analogous to the MODULE_SIG and MODULE_SIG_FORCE for modules, KEXEC_SIG turns on the signature verification but allows unsigned images to be loaded. KEXEC_SIG_FORCE disallows images without a valid signature.
[Modified by David Howells such that:
(1) verify_pefile_signature() differentiates between no-signature and sig-didn't-match in its returned errors.
(2) kexec fails with EKEYREJECTED and logs an appropriate message if signature checking is enforced and an signature is not found, uses unsupported crypto or has no matching key.
(3) kexec fails with EKEYREJECTED if there is a signature for which we have a key, but signature doesn't match - even if in non-forcing mode.
(4) kexec fails with EBADMSG or some other error if there is a signature which cannot be parsed - even if in non-forcing mode.
(5) kexec fails with ELIBBAD if the PE file cannot be parsed to extract the signature - even if in non-forcing mode.
]
--- arch/x86/Kconfig | 20 ++++++++--- crypto/asymmetric_keys/verify_pefile.c | 4 ++- include/linux/kexec.h | 4 +-- kernel/kexec_file.c | 48 ++++++++++++++++++++++---- 4 files changed, 61 insertions(+), 15 deletions(-)
arch/x86/Kconfig +15 -5
@@ -2016,20 +2016,30 @@ config KEXEC_FILE config ARCH_HAS_KEXEC_PURGATORY def_bool KEXEC_FILE -config KEXEC_VERIFY_SIG +config KEXEC_SIG bool "Verify kernel signature during kexec_file_load() syscall" depends on KEXEC_FILE ---help--- - This option makes kernel signature verification mandatory for - the kexec_file_load() syscall. - In addition to that option, you need to enable signature + This option makes the kexec_file_load() syscall check for a valid + signature of the kernel image. The image can still be loaded without + a valid signature unless you also enable KEXEC_SIG_FORCE, though if + there's a signature that we can check, then it must be valid. + + In addition to this option, you need to enable signature verification for the corresponding kernel image type being loaded in order for this to work. +config KEXEC_SIG_FORCE + bool "Require a valid signature in kexec_file_load() syscall" + depends on KEXEC_SIG + ---help--- + This option makes kernel signature verification mandatory for + the kexec_file_load() syscall. + config KEXEC_BZIMAGE_VERIFY_SIG bool "Enable bzImage signature verification support" - depends on KEXEC_VERIFY_SIG + depends on KEXEC_SIG depends on SIGNED_PE_FILE_VERIFICATION select SYSTEM_TRUSTED_KEYRING ---help---
crypto/asymmetric_keys/verify_pefile.c +3 -1
@@ -100,7 +100,7 @@ static int pefile_parse_binary(const void *pebuf, unsigned int pelen,if (!ddir->certs.virtual_address || !ddir->certs.size) {pr_debug ("Unsigned PE binary\n" ); -return -EKEYREJECTED ; +return -ENODATA ; } chkaddr(ctx->header_size, ddir->certs.virtual_address,
@@ -408,6 +408,8 @@ static int pefile_digest_pe(const void *pebuf, unsigned int pelen,* (*) 0 if at least one signature chain intersects with the keys in the trust * keyring, or: * +* (*) -ENODATA if there is no signature present. +* * (*) -ENOPKG if a suitable crypto module couldn't be found for a check on a * chain. *
include/linux/kexec.h +2 -2
@@ -125,7 +125,7 @@ typedef void *(kexec_load_t)(struct kimage *image, char *kernel_buf, unsigned long cmdline_len);typedef int (kexec_cleanup_t )(void *loader_data); -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC_SIG typedef int (kexec_verify_sig_t )(const char *kernel_buf,unsigned long kernel_len);#endif
@@ -134,7 +134,7 @@ struct kexec_file_ops {kexec_probe_t *probe;kexec_load_t *load;kexec_cleanup_t *cleanup; -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC_SIG kexec_verify_sig_t *verify_sig;#endif };
kernel/kexec_file.c +41 -7
70 lines not on this page · raw message
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 8/27 kexec_file: Restrict at runtime if the kernel is locked down
In reply to Matthew GarrettFrom: Jiri Bohac <[email protected]>
When KEXEC_SIG is not enabled, kernel should not load images through kexec_file systemcall if the kernel is locked down unless IMA can be used to validate the image.
[Modified by David Howells to fit with modifications to the previous patch
and to return -EPERM if the kernel is locked down for consistency with other lockdowns]
--- include/linux/ima.h | 6 ++++++ kernel/kexec_file.c | 8 ++++++++ 2 files changed, 14 insertions(+)
include/linux/ima.h +6 -0
@@ -127,4 +127,10 @@ static inline int ima_inode_removexattr(struct dentry *dentry,return 0 ; }#endif /* CONFIG_IMA_APPRAISE */ + +static inline bool is_ima_kexec_appraise_enabled (void ) +{ +return IS_ENABLED (CONFIG_IMA_APPRAISE_REQUIRE_KEXEC_SIGS ); +} +#endif /* _LINUX_IMA_H */
kernel/kexec_file.c +8 -0
@@ -239,6 +239,14 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd, } ret =0 ; +if (is_ima_kexec_appraise_enabled ()) +break ; + +if (kernel_is_locked_down (reason)) { + ret = -EPERM ; + goto out; + } +break ;/* All other errors are fatal, including nomem, unparseable
Signature · 1 line
2.21.0.352.gf09ad66450-goog
Re: [PATCH 08/27] kexec_file: Restrict at runtime if the kernel is locked down
Hi Jiri,
Thank you for thinking about IMA.
Quoted 5 lines · Matthew Garrett
From: Jiri Bohac <[email protected]>
When
KEXEC_SIGis not enabled, kernel should not load images throughkexec_filesystemcall if the kernel is locked down unless IMA can be used to validate the image.
This patch is a partial solution, but it doesn't take into account the architecture specific or custom policies.
Mimi
Quoted 49 lines
[Modified by David Howells to fit with modifications to the previous patch
and to return-EPERMif the kernel is locked down for consistency with other lockdowns]Signed-off-by Jiri Bohac <[email protected]>Signed-off-by David Howells <[email protected]>Reviewed-by Jiri Bohac <[email protected]>Cc Matthew Garrett <[email protected]>cc Chun-Yi Lee <[email protected]>--- include/linux/ima.h | 6 ++++++ kernel/kexec_file.c | 8 ++++++++ 2 files changed, 14 insertions(+)include/linux/ima.h +6
-0@@ -127,4 +127,10 @@ static inline int ima_inode_removexattr(struct dentry *dentry,return 0 ; }#endif /* CONFIG_IMA_APPRAISE */ + +static inline bool is_ima_kexec_appraise_enabled (void ) +{ +return IS_ENABLED (CONFIG_IMA_APPRAISE_REQUIRE_KEXEC_SIGS ); +} +#endif /* _LINUX_IMA_H */ kernel/kexec_file.c +8
-0@@ -239,6 +239,14 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd, } ret =0 ; +if (is_ima_kexec_appraise_enabled ()) +break ; + +if (kernel_is_locked_down (reason)) { + ret = -EPERM ; + goto out; + } +break ;/* All other errors are fatal, including nomem, unparseable
PATCH 9/27 hibernate: Disable when the kernel is locked down
In reply to Matthew GarrettFrom: Josh Boyer <[email protected]>
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.
--- kernel/power/hibernate.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/power/hibernate.c +1 -1
@@ -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" ); }/**
Signature · 1 line
2.21.0.352.gf09ad66450-goog
Re: [PATCH 09/27] hibernate: Disable when the kernel is locked down
Quoted 11 lines · Matthew Garrett
From: Josh Boyer <[email protected]>
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 <[email protected]>Signed-off-by David Howells <[email protected]>Reviewed-by "Lee, Chun-Yi" <[email protected]>
It would be good to cc hibernation maintainers here.
Quoted 17 lines
--- kernel/power/hibernate.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)kernel/power/hibernate.c +1
-1@@ -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" ); }/**
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
PATCH 10/27 uswsusp: Disable when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
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.
--- kernel/power/user.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/power/user.c +3 -0
@@ -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 )) {
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 11/27 PCI: Lock down BAR access when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
Any hardware that can potentially generate DMA has to be locked down in order to avoid it being possible for an attacker to modify kernel code, allowing them to circumvent disabled module loading or module signing. Default to paranoid - in future we can potentially relax this for sufficiently IOMMU-isolated devices.
--- drivers/pci/pci-sysfs.c | 9 +++++++++ drivers/pci/proc.c | 9 ++++++++- drivers/pci/syscall.c | 3 ++- 3 files changed, 19 insertions(+), 2 deletions(-)
drivers/pci/pci-sysfs.c +9 -0
@@ -905,6 +905,9 @@ static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,loff_t init_off = off;u8 *data = (u8 *) buf; +if (kernel_is_locked_down ("Direct PCI access" )) +return -EPERM ; +if (off > dev->cfg_size)return 0 ;if (off + count > dev->cfg_size) {
@@ -1167,6 +1170,9 @@ static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,enum pci_mmap_state mmap_type;struct resource *res = &pdev->resource[bar]; +if (kernel_is_locked_down ("Direct PCI access" )) +return -EPERM ; +if (res->flags &IORESOURCE_MEM &&iomem_is_exclusive (res->start))return -EINVAL ;
@@ -1242,6 +1248,9 @@ static ssize_t pci_write_resource_io(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { + if (kernel_is_locked_down("Direct PCI access")) + return -EPERM; +return pci_resource_io (filp, kobj, attr, buf, off, count, true); }
drivers/pci/proc.c +8 -1
@@ -117,6 +117,9 @@ static ssize_t proc_bus_pci_write(struct file *file, const char __user *buf,int size = dev->cfg_size;int cnt; +if (kernel_is_locked_down ("Direct PCI access" )) +return -EPERM ; +if (pos >= size)return 0 ;if (nbytes >= size)
@@ -196,6 +199,9 @@ static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,#endif /* HAVE_PCI_MMAP */ int ret =0 ; +if (kernel_is_locked_down ("Direct PCI access" )) +return -EPERM ; +switch (cmd) {case PCIIOC_CONTROLLER : ret =pci_domain_nr (dev->bus);
@@ -237,7 +243,8 @@ static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)struct pci_filp_private *fpriv = file->private_data;int i, ret, write_combine =0 , res_bit =IORESOURCE_MEM ; -if (!capable (CAP_SYS_RAWIO )) +if (!capable (CAP_SYS_RAWIO ) || +kernel_is_locked_down ("Direct PCI access" ))return -EPERM ;if (fpriv->mmap_state == pci_mmap_io) {
drivers/pci/syscall.c +2 -1
@@ -90,7 +90,8 @@ SYSCALL_DEFINE5(pciconfig_write, unsigned long, bus, unsigned long, dfn,u32 dword;int err =0 ; -if (!capable (CAP_SYS_ADMIN )) +if (!capable (CAP_SYS_ADMIN ) || +kernel_is_locked_down ("Direct PCI access" ))return -EPERM ; dev =pci_get_domain_bus_and_slot (0 , bus, dfn);
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 12/27 x86: Lock down IO port access when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
IO port access would permit users to gain access to PCI configuration registers, which in turn (on a lot of hardware) give access to MMIO register space. This would potentially permit root to trigger arbitrary DMA, so lock it down by default.
This also implicitly locks down the KDADDIO, KDDELIO, KDENABIO and KDDISABIO console ioctls.
--- arch/x86/kernel/ioport.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
arch/x86/kernel/ioport.c +4 -2
@@ -31,7 +31,8 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)if ((from + num <= from) || (from + num >IO_BITMAP_BITS ))return -EINVAL ; -if (turn_on && !capable (CAP_SYS_RAWIO )) +if (turn_on && (!capable (CAP_SYS_RAWIO ) || +kernel_is_locked_down ("ioperm" )))return -EPERM ;/*
@@ -126,7 +127,8 @@ SYSCALL_DEFINE1(iopl, unsigned int, level)return -EINVAL ;/* Trying to gain more privileges? */ if (level > old) { -if (!capable (CAP_SYS_RAWIO )) +if (!capable (CAP_SYS_RAWIO ) || +kernel_is_locked_down ("iopl" ))return -EPERM ; } regs->flags = (regs->flags & ~X86_EFLAGS_IOPL) |
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 13/27 x86/msr: Restrict MSR access when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
Writing to MSRs should not be allowed if the kernel is locked down, since it could lead to execution of arbitrary code in kernel mode. Based on a patch by Kees Cook.
MSR accesses are logged for the purposes of building up a whitelist as per Alan Cox's suggestion.
--- arch/x86/kernel/msr.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
arch/x86/kernel/msr.c +10 -0
@@ -84,6 +84,11 @@ static ssize_t msr_write(struct file *file, const char __user *buf,int err =0 ;ssize_t bytes =0 ; +if (kernel_is_locked_down ("Direct MSR access" )) { +pr_info ("Direct access to MSR %x\n" , reg); +return -EPERM ; + } +if (count %8 )return -EINVAL ;/* Invalid chunk size */
@@ -135,6 +140,11 @@ static long msr_ioctl(struct file *file, unsigned int ioc, unsigned long arg) err = -EFAULT ;break ; } +if (kernel_is_locked_down ("Direct MSR access" )) { +pr_info ("Direct access to MSR %x\n" , regs[1 ]);/* Display %ecx */ + err = -EPERM ; +break ; + } err =wrmsr_safe_regs_on_cpu (cpu, regs);if (err)break ;
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 14/27 ACPI: Limit access to custom_method when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
custom_method effectively allows arbitrary access to system memory, making it possible for an attacker to circumvent restrictions on module loading. Disable it if the kernel is locked down.
--- drivers/acpi/custom_method.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/acpi/custom_method.c +3 -0
@@ -29,6 +29,9 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,struct acpi_table_header table;acpi_status status; +if (kernel_is_locked_down ("ACPI custom methods" )) +return -EPERM ; +if (!(*ppos)) {/* parse the table header to get the table length */ if (count <=sizeof (struct acpi_table_header ))
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 15/27 acpi: Ignore acpi_rsdp kernel param when the kernel has been locked down
In reply to Matthew GarrettFrom: Josh Boyer <[email protected]>
This option allows userspace to pass the RSDP address to the kernel, which makes it possible for a user to modify the workings of hardware . Reject the option when the kernel is locked down.
--- drivers/acpi/osl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/acpi/osl.c +1 -1
@@ -194,7 +194,7 @@ acpi_physical_address __init acpi_os_get_root_pointer(void)acpi_physical_address pa;#ifdef CONFIG_KEXEC -if (acpi_rsdp) +if (acpi_rsdp && !kernel_is_locked_down ("ACPI RSDP specification" ))return acpi_rsdp;#endif pa =acpi_arch_get_root_pointer ();
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 16/27 acpi: Disable ACPI table override if the kernel is locked down
In reply to Matthew GarrettFrom: Linn Crosetto <[email protected]>
From the kernel documentation (initrd_table_override.txt):
If the ACPI_INITRD_TABLE_OVERRIDE compile option is true, it is possible to override nearly any ACPI table provided by the BIOS with an instrumented, modified one.
When securelevel is set, the kernel should disallow any unauthenticated changes to kernel space. ACPI tables contain code invoked by the kernel, so do not allow ACPI tables to be overridden if the kernel is locked down.
--- drivers/acpi/tables.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/acpi/tables.c +5 -0
@@ -531,6 +531,11 @@ void __init acpi_table_upgrade(void)if (table_nr ==0 )return ; +if (kernel_is_locked_down ("ACPI table override" )) { +pr_notice ("kernel is locked down, ignoring table override\n" ); +return ; + } + acpi_tables_addr =memblock_find_in_range (0 ,ACPI_TABLE_UPGRADE_MAX_PHYS , all_tables_size,PAGE_SIZE );
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 17/27 acpi: Disable APEI error injection if the kernel is locked down
In reply to Matthew GarrettFrom: Linn Crosetto <[email protected]>
ACPI provides an error injection mechanism, EINJ, for debugging and testing the ACPI Platform Error Interface (APEI) and other RAS features. If supported by the firmware, ACPI specification 5.0 and later provide for a way to specify a physical memory address to which to inject the error.
Injecting errors through EINJ can produce errors which to the platform are indistinguishable from real hardware errors. This can have undesirable side-effects, such as causing the platform to mark hardware as needing replacement.
While it does not provide a method to load unauthenticated privileged code, the effect of these errors may persist across reboots and affect trust in the underlying hardware, so disable error injection through EINJ if the kernel is locked down.
--- drivers/acpi/apei/einj.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/acpi/apei/einj.c +3 -0
@@ -518,6 +518,9 @@ static int einj_error_inject(u32 type, u32 flags, u64 param1, u64 param2,int rc;u64 base_addr, size; +if (kernel_is_locked_down ("ACPI error injection" )) +return -EPERM ; +/* If user manually set "flags", make sure it is legal */ if (flags && (flags & ~(SETWA_FLAGS_APICID |SETWA_FLAGS_MEM |SETWA_FLAGS_PCIE_SBDF )))
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 18/27 Prohibit PCMCIA CIS storage when the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Prohibit replacement of the PCMCIA Card Information Structure when the kernel is locked down.
--- drivers/pcmcia/cistpl.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/pcmcia/cistpl.c +3 -0
@@ -1578,6 +1578,9 @@ static ssize_t pccard_store_cis(struct file *filp, struct kobject *kobj,struct pcmcia_socket *s;int error; +if (kernel_is_locked_down ("Direct PCMCIA CIS storage" )) +return -EPERM ; + s = to_socket(container_of(kobj, struct device, kobj));if (off)
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 19/27 Lock down TIOCSSERIAL
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Lock down TIOCSSERIAL as that can be used to change the ioport and irq settings on a serial port. This only appears to be an issue for the serial drivers that use the core serial code. All other drivers seem to either ignore attempts to change port/irq or give an error.
--- drivers/tty/serial/serial_core.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/tty/serial/serial_core.c +6 -0
@@ -852,6 +852,12 @@ static int uart_set_info(struct tty_struct *tty, struct tty_port *port, new_flags = (__force upf_t )new_info->flags; old_custom_divisor = uport->custom_divisor; +if ((change_port || change_irq) && +kernel_is_locked_down ("Using TIOCSSERIAL to change device addresses, irqs and dma channels" )) { + retval = -EPERM ; + goto exit; + } +if (!capable (CAP_SYS_ADMIN )) { retval = -EPERM ; if (change_irq || change_port ||
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 20/27 Lock down module params that specify hardware parameters (eg. ioport)
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Provided an annotation for module parameters that specify hardware parameters (such as io ports, iomem addresses, irqs, dma channels, fixed dma buffers and other types).
--- kernel/params.c | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-)
kernel/params.c +21 -5
@@ -108,13 +108,19 @@ bool parameq(const char *a, const char *b)return parameqn (a, b,strlen (a)+1 ); } -static void param_check_unsafe (const struct kernel_param *kp) +static bool param_check_unsafe (const struct kernel_param *kp, +const char *doing) {if (kp->flags &KERNEL_PARAM_FL_UNSAFE ) {pr_notice ("Setting dangerous option %s - tainting kernel\n" , kp->name);add_taint (TAINT_USER ,LOCKDEP_STILL_OK ); } + +if (kp->flags &KERNEL_PARAM_FL_HWPARAM && +kernel_is_locked_down ("Command line-specified device addresses, irqs and dma channels" )) +return false; +return true; } static int parse_one(char *param,
@@ -144,8 +150,10 @@ static int parse_one(char *param,pr_debug ("handling %s with %p\n" , param, params[i].ops->set);kernel_param_lock (params[i].mod); -param_check_unsafe (¶ms[i]); - err = params[i].ops->set (val, ¶ms[i]); +if (param_check_unsafe (¶ms[i], doing)) + err = params[i].ops->set (val, ¶ms[i]); +else + err = -EPERM ;kernel_param_unlock (params[i].mod);return err; }
@@ -553,6 +561,12 @@ static ssize_t param_attr_show(struct module_attribute *mattr,return count; } +#ifdef CONFIG_MODULES +#define mod_name (mod) (mod)->name +#else +#define mod_name (mod) "unknown" +#endif +/* sysfs always hands a nul-terminated string in buf. We rely on that. */ static ssize_t param_attr_store(struct module_attribute *mattr, struct module_kobject *mk,
@@ -565,8 +579,10 @@ static ssize_t param_attr_store(struct module_attribute *mattr,return -EPERM ;kernel_param_lock (mk->mod); -param_check_unsafe (attribute->param); - err = attribute->param->ops->set (buf, attribute->param); +if (param_check_unsafe (attribute->param,mod_name (mk->mod))) + err = attribute->param->ops->set (buf, attribute->param); +else + err = -EPERM ;kernel_param_unlock (mk->mod);if (!err)return len;
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 21/27 x86/mmiotrace: Lock down the testmmiotrace module
In reply to Matthew GarrettFrom: David Howells <[email protected]>
The testmmiotrace module shouldn't be permitted when the kernel is locked down as it can be used to arbitrarily read and write MMIO space.
--- arch/x86/mm/testmmiotrace.c | 3 +++ 1 file changed, 3 insertions(+)
arch/x86/mm/testmmiotrace.c +3 -0
@@ -115,6 +115,9 @@ static int __init init(void) {unsigned long size = (read_far) ? (8 <<20 ) : (16 <<10 ); +if (kernel_is_locked_down ("MMIO trace testing" )) +return -EPERM ; +if (mmio_address ==0 ) {pr_err ("you have to use the module argument mmio_address.\n" );pr_err ("DO NOT LOAD THIS MODULE UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!\n" );
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 22/27 Lock down /proc/kcore
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow access to /proc/kcore when the kernel is locked down to prevent access to cryptographic data.
--- fs/proc/kcore.c | 2 ++ 1 file changed, 2 insertions(+)
fs/proc/kcore.c +2 -0
@@ -518,6 +518,8 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)static int open_kcore (struct inode *inode,struct file *filp) { +if (kernel_is_locked_down ("/proc/kcore" )) +return -EPERM ;if (!capable (CAP_SYS_RAWIO ))return -EPERM ;
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 23/27 Lock down kprobes
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow the creation of kprobes when the kernel is locked down by preventing their registration. This prevents kprobes from being used to access kernel memory, either to make modifications or to steal crypto data.
--- kernel/kprobes.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/kprobes.c +3 -0
@@ -1552,6 +1552,9 @@ int register_kprobe(struct kprobe *p)struct module *probed_mod;kprobe_opcode_t *addr; +if (kernel_is_locked_down ("Use of kprobes" )) +return -EPERM ; +/* Adjust probe address from symbol */ addr =kprobe_addr (p);if (IS_ERR (addr))
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 24/27 bpf: Restrict kernel image access functions when the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
There are some bpf functions can be used to read kernel memory:bpf_probe_read, bpf_probe_write_user and bpf_trace_printk. These allow private keys in kernel memory (e.g. the hibernation image signing key) to be read by an eBPF program and kernel memory to be altered without restriction.
Completely prohibit the use of BPF when the kernel is locked down.
--- kernel/bpf/syscall.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/bpf/syscall.c +3 -0
@@ -2593,6 +2593,9 @@ SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, sizif (sysctl_unprivileged_bpf_disabled && !capable (CAP_SYS_ADMIN ))return -EPERM ; +if (kernel_is_locked_down ("BPF" )) +return -EPERM ; + err =bpf_check_uarg_tail_zero (uattr,sizeof (attr), size);if (err)return err;
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 25/27 Lock down perf
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow the use of certain perf facilities that might allow userspace to access kernel data.
--- kernel/events/core.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/events/core.c +5 -0
@@ -10477,6 +10477,11 @@ SYSCALL_DEFINE5(perf_event_open,return -EINVAL ; } +if ((attr.sample_type &PERF_SAMPLE_REGS_INTR ) && +kernel_is_locked_down ("PERF_SAMPLE_REGS_INTR" )) +/* REGS_INTR can leak data, lockdown must prevent this */ +return -EPERM ; +/* Only privileged users can get physical addresses */ if ((attr.sample_type &PERF_SAMPLE_PHYS_ADDR ) &&perf_paranoid_kernel () && !capable (CAP_SYS_ADMIN ))
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 26/27 debugfs: Restrict debugfs when the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow opening of debugfs files that might be used to muck around when the kernel is locked down as various drivers give raw access to hardware through debugfs. Given the effort of auditing all 2000 or so files and manually fixing each one as necessary, I've chosen to apply a heuristic instead. The following changes are made:
(1) chmod and chown are disallowed on debugfs objects (though the root dir can be modified by mount and remount, but I'm not worried about that).
(2) When the kernel is locked down, only files with the following criteria are permitted to be opened:
- The file must have mode 00444
- The file must not have ioctl methods
- The file must not have mmap
(3) When the kernel is locked down, files may only be opened for reading.
Normal device interaction should be done through configfs, sysfs or a miscdev, not debugfs.
Note that this makes it unnecessary to specifically lock down show_dsts(), show_devs() and show_call() in the asus-wmi driver.
I would actually prefer to lock down all files by default and have the the files unlocked by the creator. This is tricky to manage correctly, though, as there are 19 creation functions and ~1600 call sites (some of them in loops scanning tables).
--- fs/debugfs/file.c | 28 ++++++++++++++++++++++++++++ fs/debugfs/inode.c | 30 ++++++++++++++++++++++++++++-- 2 files changed, 56 insertions(+), 2 deletions(-)
fs/debugfs/file.c +28 -0
@@ -136,6 +136,25 @@ void debugfs_file_put(struct dentry *dentry) }EXPORT_SYMBOL_GPL (debugfs_file_put); +/* +* Only permit access to world-readable files when the kernel is locked down. +* We also need to exclude any file that has ways to write or alter it as root +* can bypass the permissions check. +*/ +static bool debugfs_is_locked_down (struct inode *inode, +struct file *filp, +const struct file_operations *real_fops) +{ +if ((inode->i_mode &07777 ) ==0444 && + !(filp->f_mode &FMODE_WRITE ) && + !real_fops->unlocked_ioctl && + !real_fops->compat_ioctl && + !real_fops->mmap) +return false; + +return kernel_is_locked_down ("debugfs" ); +} +static int open_proxy_open (struct inode *inode,struct file *filp) {struct dentry *dentry =F_DENTRY (filp);
@@ -147,6 +166,11 @@ static int open_proxy_open(struct inode *inode, struct file *filp)return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); + + r = -EPERM ; +if (debugfs_is_locked_down (inode, filp, real_fops)) + goto out; + real_fops =fops_get (real_fops);if (!real_fops) {/* Huh? Module did not clean up after itself at exit? */
@@ -272,6 +296,10 @@ static int full_proxy_open(struct inode *inode, struct file *filp)return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); + r = -EPERM ; +if (debugfs_is_locked_down (inode, filp, real_fops)) + goto out; + real_fops =fops_get (real_fops);if (!real_fops) {/* Huh? Module did not cleanup after itself at exit? */
fs/debugfs/inode.c +28 -2
@@ -32,6 +32,31 @@ static struct vfsmount *debugfs_mount;static int debugfs_mount_count;static bool debugfs_registered; +/* +* Don't allow access attributes to be changed whilst the kernel is locked down +* so that we can use the file mode as part of a heuristic to determine whether +* to lock down individual files. +*/ +static int debugfs_setattr (struct dentry *dentry,struct iattr *ia) +{ +if ((ia->ia_valid & (ATTR_MODE |ATTR_UID |ATTR_GID )) && +kernel_is_locked_down ("debugfs" )) +return -EPERM ; +return simple_setattr (dentry, ia); +} + +static const struct inode_operations debugfs_file_inode_operations = { + .setattr = debugfs_setattr, +}; +static const struct inode_operations debugfs_dir_inode_operations = { + .lookup = simple_lookup, + .setattr = debugfs_setattr, +}; +static const struct inode_operations debugfs_symlink_inode_operations = { + .get_link = simple_get_link, + .setattr = debugfs_setattr, +}; +static struct inode *debugfs_get_inode (struct super_block *sb) {struct inode *inode =new_inode (sb);
@@ -356,6 +381,7 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode, inode->i_mode = mode; inode->i_private = data; + inode->i_op = &debugfs_file_inode_operations; inode->i_fop = proxy_fops; dentry->d_fsdata = (void *)((unsigned long )real_fops |DEBUGFS_FSDATA_IS_REAL_FOPS_BIT );
@@ -516,7 +542,7 @@ struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)return failed_creating (dentry); inode->i_mode =S_IFDIR |S_IRWXU |S_IRUGO |S_IXUGO ; - inode->i_op = &simple_dir_inode_operations; + inode->i_op = &debugfs_dir_inode_operations; inode->i_fop = &simple_dir_operations;/* directory inodes start off with i_nlink == 2 (for "." entry) */
@@ -611,7 +637,7 @@ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,return failed_creating (dentry); } inode->i_mode =S_IFLNK |S_IRWXUGO ; - inode->i_op = &simple_symlink_inode_operations; + inode->i_op = &debugfs_symlink_inode_operations; inode->i_link = link;d_instantiate (dentry, inode);return end_creating (dentry);
Signature · 1 line
2.21.0.352.gf09ad66450-goog
PATCH 27/27 lockdown: Print current->comm in restriction messages
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Print the content of current->comm in messages generated by lockdown to indicate a restriction that was hit. This makes it a bit easier to find out what caused the message.
The message now patterned something like:
Lockdown: <comm>: <what> is restricted; see man kernel_lockdown.7
--- security/lock_down.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
security/lock_down.c +2 -2
@@ -58,8 +58,8 @@ void __init init_lockdown(void)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); +pr_notice ("Lockdown: %s: %s is restricted; see man kernel_lockdown.7\n" , + current->comm, what);return kernel_locked_down; }EXPORT_SYMBOL (__kernel_is_locked_down);
Signature · 1 line
2.21.0.352.gf09ad66450-goog
Quoted 11 lines · Matthew Garrett
Hi James,
David is low on cycles at the moment, so I'm taking over for this time round. This patchset introduces an optional kernel lockdown feature, intended to strengthen the boundary between UID 0 and the kernel. When enabled and active (by enabling the config option and passing the "lockdown" option on the kernel command line), various pieces of kernel functionality are restricted. Applications that rely on low-level access to either hardware or the kernel may cease working as a result - therefore this should not be enabled without appropriate evaluation beforehand.
Documentation/process/submitting-patches.rst says (IMO) that these patches should also have Signed-of-by: <you>.
"The Signed-off-by: tag indicates that the signer was involved in the development of the patch, or that he/she was in the patch's delivery path."
Also, the sysrq key usage should be documented inDocumentation/admin-guide/sysrq.rst.
Quoted 123 lines
The majority of mainstream distributions have been carrying variants of this patchset for many years now, so there's value in providing a unified upstream implementation to reduce the delta. This PR probably doesn't meet every distribution requirement, but gets us much closer to not requiring external patches.
This PR is mostly the same as the previous attempt, but with the following changes:
1) The integration between EFI secure boot and the lockdown state has been removed
2) A newCONFIG_KERNEL_LOCK_DOWN_FORCEkconfig option has been added, which will always enable lockdown regardless of the kernel command line
3) The integration with IMA has been dropped for now. Requiring the use of the IMA secure boot policy when lockdown is enabled isn't practical for most distributions at the moment, as there's still not a great deal of infrastructure for shipping packages with appropriate IMA signatures, and it makes it complicated for end users to manage custom IMA policies.The following changes since commit
a3b22b9f11d9fbc48b0291ea92259a5a810e9438:Linux 5.0-rc7 (2019-02-17 18:46:40 -0800)
are available in the Git repository at:
https://github.com/mjg59/linux
lock_downfor you to fetch changes up to
43e004ecae91bf9159b8e91cd1d613e58b8f63f8:lockdown: Print
current->commin restriction messages (2019-02-28
11:19:23 -0800)----------------------------------------------------------------
Dave Young (1):
Copysecure_bootflag in boot params across kexec rebootDavid Howells (12):
Add the ability to lock down access to the running kernel image Enforce module signatures if the kernel is locked down Prohibit PCMCIA CIS storage when the kernel is locked down Lock down TIOCSSERIAL
Lock down module params that specify hardware parameters (eg. ioport) x86/mmiotrace: Lock down the testmmiotrace module
Lock down/proc/kcore
Lock down kprobes
bpf: Restrict kernel image access functions when the kernel is locked down Lock down perf
debugfs: Restrict debugfs when the kernel is locked down
lockdown: Printcurrent->commin restriction messagesJiri Bohac (2):
kexec_file: splitKEXEC_VERIFY_SIGintoKEXEC_SIGandKEXEC_SIG_FORCE
kexec_file: Restrict at runtime if the kernel is locked downJosh Boyer (2):
hibernate: Disable when the kernel is locked down
acpi: Ignoreacpi_rsdpkernel param when the kernel has been locked downKyle McMartin (1):
Add a SysRq option to lift kernel lockdownLinn Crosetto (2):
acpi: Disable ACPI table override if the kernel is locked down
acpi: Disable APEI error injection if the kernel is locked downMatthew Garrett (7):
Restrict/dev/{mem,kmem,port}when the kernel is locked down
kexec_load: Disable at runtime if the kernel is locked down
uswsusp: Disable when the kernel is locked down
PCI: Lock down BAR access when the kernel is locked down
x86: Lock down IO port access when the kernel is locked down x86/msr: Restrict MSR access when the kernel is locked down
ACPI: Limit access tocustom_methodwhen the kernel is locked downarch/x86/Kconfig | 20 ++++++++++++----- arch/x86/include/asm/setup.h | 2 ++ arch/x86/kernel/ioport.c | 6 ++++-- arch/x86/kernel/kexec-bzimage64.c | 1 + arch/x86/kernel/msr.c | 10 +++++++++ arch/x86/mm/testmmiotrace.c | 3 +++ crypto/asymmetric_keys/verify_pefile.c | 4 +++- drivers/acpi/apei/einj.c | 3 +++ drivers/acpi/custom_method.c | 3 +++ drivers/acpi/osl.c | 2 +- drivers/acpi/tables.c | 5 +++++ drivers/char/mem.c | 2 ++ drivers/input/misc/uinput.c | 1 + drivers/pci/pci-sysfs.c | 9 ++++++++ drivers/pci/proc.c | 9 +++++++- drivers/pci/syscall.c | 3 ++- drivers/pcmcia/cistpl.c | 3 +++ drivers/tty/serial/serial_core.c | 6 ++++++ drivers/tty/sysrq.c | 19 +++++++++++------ fs/debugfs/file.c | 28 ++++++++++++++++++++++++ fs/debugfs/inode.c | 30 ++++++++++++++++++++++++-- fs/proc/kcore.c | 2 ++ include/linux/ima.h | 6 ++++++ include/linux/input.h | 5 +++++ include/linux/kernel.h | 17 +++++++++++++++ include/linux/kexec.h | 4 ++-- include/linux/security.h | 9 +++++++- include/linux/sysrq.h | 8 ++++++- kernel/bpf/syscall.c | 3 +++ kernel/debug/kdb/kdb_main.c | 2 +- kernel/events/core.c | 5 +++++ kernel/kexec.c | 7 ++++++ kernel/kexec_file.c | 56 ++++++++++++++++++++++++++++++++++++++++++------ kernel/kprobes.c | 3 +++ kernel/module.c | 56 ++++++++++++++++++++++++++++++++++++------------ kernel/params.c | 26 ++++++++++++++++++----- kernel/power/hibernate.c | 2 +- kernel/power/user.c | 3 +++ security/Kconfig | 24 +++++++++++++++++++++ security/Makefile | 3 +++ security/lock_down.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 41 files changed, 466 insertions(+), 50 deletions(-) create mode 100644 security/lock_down.c
Signature · 1 line
~Randy
Hi James,
Based on feedback, I'm going to make a couple of small changes to this patchset and then resend.