Add kernel lockdown functionality
Subsystems (39)
v40 cover Add kernel lockdown functionality
After chatting with James in person, I'm resending the full set with the fixes merged in in order to avoid any bisect issues. There should be no functional changes other than avoiding build failures with some configs, and fixing the oops in tracefs.
PATCH v40 1/29 security: Support early LSMs
The lockdown module is intended to allow for kernels to be locked down early in boot - sufficiently early that we don't have the ability to kmalloc() yet. Add support for early initialisation of some LSMs, and then add them to the list of names when we do full initialisation later. Early LSMs are initialised in link order and cannot be overridden via boot parameters, and cannot make use of kmalloc() (since the allocator isn't initialised yet).
(Fixed by Stephen Rothwell to include a stub to fix builds when !CONFIG_SECURITY)
--- include/asm-generic/vmlinux.lds.h | 8 ++++- include/linux/lsm_hooks.h | 6 ++++ include/linux/security.h | 6 ++++ init/main.c | 1 + security/security.c | 50 ++++++++++++++++++++++++++----- 5 files changed, 62 insertions(+), 9 deletions(-)
include/asm-generic/vmlinux.lds.h +7 -1
@@ -208,8 +208,13 @@ __start_lsm_info = .; \ KEEP(*(.lsm_info.init)) \ __end_lsm_info = .; +#define EARLY_LSM_TABLE () . = ALIGN(8); \ + __start_early_lsm_info = .; \ + KEEP(*(.early_lsm_info.init)) \ + __end_early_lsm_info = .;#else #define LSM_TABLE () +#define EARLY_LSM_TABLE ()#endif #define ___OF_TABLE (cfg, name) _OF_TABLE_##cfg(name)
@@ -609,7 +614,8 @@ ACPI_PROBE_TABLE(irqchip) \ ACPI_PROBE_TABLE(timer) \ EARLYCON_TABLE() \ - LSM_TABLE() + LSM_TABLE() \ + EARLY_LSM_TABLE()#define INIT_TEXT \ *(.init.text .init.text.*) \
include/linux/lsm_hooks.h +6 -0
@@ -2104,12 +2104,18 @@ struct lsm_info { };extern struct lsm_info __start_lsm_info[], __end_lsm_info[]; +extern struct lsm_info __start_early_lsm_info[], __end_early_lsm_info[];#define DEFINE_LSM (lsm) \ static struct lsm_info __lsm_##lsm \ __used __section(.lsm_info.init) \ __aligned(sizeof(unsigned long)) +#define DEFINE_EARLY_LSM (lsm) \ + static struct lsm_info __early_lsm_##lsm \ + __used __section(.early_lsm_info.init) \ + __aligned(sizeof(unsigned long)) +#ifdef CONFIG_SECURITY_SELINUX_DISABLE /* * Assuring the safety of deleting a security module is up to
include/linux/security.h +6 -0
@@ -195,6 +195,7 @@ int unregister_lsm_notifier(struct notifier_block *nb);/* prototypes */ extern int security_init (void ); +extern int early_security_init (void );/* Security operations */ int security_binder_set_context_mgr (struct task_struct *mgr);
@@ -423,6 +424,11 @@ static inline int security_init(void)return 0 ; } +static inline int early_security_init (void ) +{ +return 0 ; +} +static inline int security_binder_set_context_mgr (struct task_struct *mgr) {return 0 ;
init/main.c +1 -0
@@ -569,6 +569,7 @@ asmlinkage __visible void __init start_kernel(void)boot_cpu_init ();page_address_init ();pr_notice ("%s" , linux_banner); +early_security_init ();setup_arch (&command_line);mm_init_cpumask (&init_mm);setup_command_line (command_line);
security/security.c +42 -8
89 lines not on this page · raw message
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 2/29 security: Add a "locked down" LSM hook
In reply to Matthew GarrettAdd a mechanism to allow LSMs to make a policy decision around whether kernel functionality that would allow tampering with or examining the runtime state of the kernel should be permitted.
--- include/linux/lsm_hooks.h | 7 +++++++ include/linux/security.h | 32 ++++++++++++++++++++++++++++++++ security/security.c | 6 ++++++ 3 files changed, 45 insertions(+)
include/linux/lsm_hooks.h +7 -0
@@ -1446,6 +1446,11 @@* @bpf_prog_free_security: * Clean up the security information stored inside bpf prog. * +* @locked_down +* Determine whether a kernel feature that potentially enables arbitrary +* code execution in kernel space should be permitted. +* +* @what: kernel feature being accessed */ union security_list_options {int (*binder_set_context_mgr)(struct task_struct *mgr);
@@ -1807,6 +1812,7 @@ union security_list_options {int (*bpf_prog_alloc_security)(struct bpf_prog_aux *aux);void (*bpf_prog_free_security)(struct bpf_prog_aux *aux);#endif /* CONFIG_BPF_SYSCALL */ +int (*locked_down)(enum lockdown_reason what); };struct security_hook_heads {
@@ -2046,6 +2052,7 @@ struct security_hook_heads {struct hlist_head bpf_prog_alloc_security;struct hlist_head bpf_prog_free_security;#endif /* CONFIG_BPF_SYSCALL */ +struct hlist_head locked_down; } __randomize_layout;/*
include/linux/security.h +32 -0
@@ -77,6 +77,33 @@ enum lsm_event { LSM_POLICY_CHANGE, }; +/* +* These are reasons that can be passed to the security_locked_down() +* LSM hook. Lockdown reasons that protect kernel integrity (ie, the +* ability for userland to modify kernel code) are placed before +* LOCKDOWN_INTEGRITY_MAX. Lockdown reasons that protect kernel +* confidentiality (ie, the ability for userland to extract +* information from the running kernel that would otherwise be +* restricted) are placed before LOCKDOWN_CONFIDENTIALITY_MAX. +* +* LSM authors should note that the semantics of any given lockdown +* reason are not guaranteed to be stable - the same reason may block +* one set of features in one kernel release, and a slightly different +* set of features in a later kernel release. LSMs that seek to expose +* lockdown policy at any level of granularity other than "none", +* "integrity" or "confidentiality" are responsible for either +* ensuring that they expose a consistent level of functionality to +* userland, or ensuring that userland is aware that this is +* potentially a moving target. It is easy to misuse this information +* in a way that could break userspace. Please be careful not to do +* so. +*/ +enum lockdown_reason { +LOCKDOWN_NONE , +LOCKDOWN_INTEGRITY_MAX , +LOCKDOWN_CONFIDENTIALITY_MAX , +}; +/* These functions are in security/commoncap.c */ extern int cap_capable (const struct cred *cred,struct user_namespace *ns,int cap,unsigned int opts);
@@ -393,6 +420,7 @@ void security_inode_invalidate_secctx(struct inode *inode);int security_inode_notifysecctx (struct inode *inode,void *ctx,u32 ctxlen);int security_inode_setsecctx (struct dentry *dentry,void *ctx,u32 ctxlen);int security_inode_getsecctx (struct inode *inode,void **ctx,u32 *ctxlen); +int security_locked_down (enum lockdown_reason what);#else /* CONFIG_SECURITY */ static inline int call_lsm_notifier (enum lsm_event event,void *data)
@@ -1210,6 +1238,10 @@ static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32 {return -EOPNOTSUPP ; } +static inline int security_locked_down (enum lockdown_reason what) +{ +return 0 ; +}#endif /* CONFIG_SECURITY */ #ifdef CONFIG_SECURITY_NETWORK
security/security.c +6 -0
@@ -2389,3 +2389,9 @@ void security_bpf_prog_free(struct bpf_prog_aux *aux) call_void_hook(bpf_prog_free_security, aux); }#endif /* CONFIG_BPF_SYSCALL */ + +int security_locked_down (enum lockdown_reason what) +{ +return call_int_hook (locked_down,0 , what); +} +EXPORT_SYMBOL (security_locked_down);
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 3/29 security: Add a static lockdown policy LSM
In reply to Matthew GarrettWhile existing LSMs can be extended to handle lockdown policy, distributions generally want to be able to apply a straightforward static policy. This patch adds a simple LSM that can be configured to reject either integrity or all lockdown queries, and can be configured at runtime (through securityfs), boot time (via a kernel parameter) or build time (via a kconfig option). Based on initial code by David Howells.
--- .../admin-guide/kernel-parameters.txt | 9 + include/linux/security.h | 3 + security/Kconfig | 11 +- security/Makefile | 2 + security/lockdown/Kconfig | 46 +++++ security/lockdown/Makefile | 1 + security/lockdown/lockdown.c | 169 ++++++++++++++++++ 7 files changed, 236 insertions(+), 5 deletions(-) create mode 100644 security/lockdown/Kconfig create mode 100644 security/lockdown/Makefile create mode 100644 security/lockdown/lockdown.c
Documentation/admin-guide/kernel-parameters.txt +9 -0
@@ -2244,6 +2244,15 @@ lockd.nlm_udpport=M [NFS] Assign UDP port. Format: <integer> + lockdown= [SECURITY] + { integrity | confidentiality } + Enable the kernel lockdown feature. If set to + integrity, kernel features that allow userland to + modify the running kernel are disabled. If set to + confidentiality, kernel features that allow userland + to extract confidential information from the kernel + are also disabled. + locktorture.nreaders_stress= [KNL] Set the number of locking read-acquisition kthreads. Defaults to being automatically set based on the
include/linux/security.h +3 -0
@@ -97,6 +97,9 @@ enum lsm_event {* potentially a moving target. It is easy to misuse this information * in a way that could break userspace. Please be careful not to do * so. +* +* If you add to this, remember to extend lockdown_reasons in +* security/lockdown/lockdown.c. */ enum lockdown_reason {LOCKDOWN_NONE ,
security/Kconfig +6 -5
@@ -237,6 +237,7 @@ source "security/apparmor/Kconfig" source "security/loadpin/Kconfig" source "security/yama/Kconfig" source "security/safesetid/Kconfig" +source "security/lockdown/Kconfig" source "security/integrity/Kconfig"
@@ -276,11 +277,11 @@ endchoice config LSM string "Ordered list of enabled LSMs" - default "yama,loadpin,safesetid,integrity,smack,selinux,tomoyo,apparmor" if DEFAULT_SECURITY_SMACK - default "yama,loadpin,safesetid,integrity,apparmor,selinux,smack,tomoyo" if DEFAULT_SECURITY_APPARMOR - default "yama,loadpin,safesetid,integrity,tomoyo" if DEFAULT_SECURITY_TOMOYO - default "yama,loadpin,safesetid,integrity" if DEFAULT_SECURITY_DAC - default "yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor" + default "lockdown,yama,loadpin,safesetid,integrity,smack,selinux,tomoyo,apparmor" if DEFAULT_SECURITY_SMACK + default "lockdown,yama,loadpin,safesetid,integrity,apparmor,selinux,smack,tomoyo" if DEFAULT_SECURITY_APPARMOR + default "lockdown,yama,loadpin,safesetid,integrity,tomoyo" if DEFAULT_SECURITY_TOMOYO + default "lockdown,yama,loadpin,safesetid,integrity" if DEFAULT_SECURITY_DAC + default "lockdown,yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor" help A comma-separated list of LSMs, in initialization order. Any LSMs left off this list will be ignored. This can be
security/Makefile +2 -0
@@ -11,6 +11,7 @@ subdir-$(CONFIG_SECURITY_APPARMOR) += apparmor subdir-$(CONFIG_SECURITY_YAMA) += yama subdir-$(CONFIG_SECURITY_LOADPIN) += loadpin subdir-$(CONFIG_SECURITY_SAFESETID) += safesetid +subdir-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown # always enable default capabilities obj-y += commoncap.o
@@ -27,6 +28,7 @@ obj-$(CONFIG_SECURITY_APPARMOR) += apparmor/ obj-$(CONFIG_SECURITY_YAMA) += yama/ obj-$(CONFIG_SECURITY_LOADPIN) += loadpin/ obj-$(CONFIG_SECURITY_SAFESETID) += safesetid/ +obj-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown/ obj-$(CONFIG_CGROUP_DEVICE) += device_cgroup.o # Object integrity file lists
security/lockdown/Kconfig new file +46 -0
46 lines not on this page · raw message
security/lockdown/Makefile new file +1 -0
@@ -0,0 +1 @@ +obj-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown.o
security/lockdown/lockdown.c new file +169 -0
169 lines not on this page · raw message
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
David Howells
maintainerRe: [PATCH V40 03/29] security: Add a static lockdown policy LSM
Quoted 1 line · Matthew Garrett
+static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
const char *const maybe?
security/lockdown/lockdown.c line 28
Quoted 4 lines
security/lockdown/lockdown.c new file +4
-0+static enum lockdown_reason lockdown_levels[] = {LOCKDOWN_NONE , +LOCKDOWN_INTEGRITY_MAX , +LOCKDOWN_CONFIDENTIALITY_MAX }; +
const?
Isn't this also a 1:1 mapping?
Quoted 1 line
+static int
lock_kernel_down(const char *where, enum lockdown_reason level)
Is the last parameter the reason or the level? You're mixing the terms.
David
Re: [PATCH V40 03/29] security: Add a static lockdown policy LSM
Quoted 6 lines · David Howells
Quoted 1 line · Matthew Garrett
+static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
const char *const maybe?
Seems reasonable.
Quoted 8 lines
security/lockdown/lockdown.c line 28
Quoted 4 lines
security/lockdown/lockdown.c new file +4
-0+static enum lockdown_reason lockdown_levels[] = {LOCKDOWN_NONE , +LOCKDOWN_INTEGRITY_MAX , +LOCKDOWN_CONFIDENTIALITY_MAX }; +const?
Isn't this also a 1:1 mapping?
Sorry, a 1:1 mapping to what?
Quoted 3 lines
Quoted 1 line
+static int
lock_kernel_down(const char *where, enum lockdown_reason level)Is the last parameter the reason or the level? You're mixing the terms.
Fair.
Re: [PATCH V40 03/29] security: Add a static lockdown policy LSM
Quoted 6 lines · Matthew Garrett
Quoted 3 lines · David Howells
Quoted 1 line
+static int
lock_kernel_down(const char *where, enum lockdown_reason level)Is the last parameter the reason or the level? You're mixing the terms.
Fair.
Actually, on re-reading, I think this correct - this is setting the lockdown level, it's just that the lockdown level is an enum lockdown_reason for the sake of convenience.
PATCH v40 4/29 lockdown: 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.
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 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.
[Modified by Matthew Garrett to remove the IMA integration. This will
be replaced with integration with the IMA architecture policy patchset.]
--- include/linux/security.h | 1 + init/Kconfig | 5 +++++ kernel/module.c | 37 +++++++++++++++++++++++++++++------- security/lockdown/Kconfig | 1 + security/lockdown/lockdown.c | 1 + 5 files changed, 38 insertions(+), 7 deletions(-)
include/linux/security.h +1 -0
@@ -103,6 +103,7 @@ enum lsm_event {*/ enum lockdown_reason {LOCKDOWN_NONE , +LOCKDOWN_MODULE_SIGNATURE ,LOCKDOWN_INTEGRITY_MAX ,LOCKDOWN_CONFIDENTIALITY_MAX , };
init/Kconfig +5 -0
@@ -1939,6 +1939,11 @@ config MODULE_SIG kernel build dependency so that the signing tool can use its crypto library. + You should enable this option if you wish to use either + CONFIG_SECURITY_LOCKDOWN_LSM or lockdown functionality imposed via + another LSM - otherwise unsigned modules will be loadable regardless + of the lockdown policy. + !!!WARNING!!! If you enable this option, you MUST make sure that the module DOES NOT get stripped after being signed. This includes the debuginfo strip done by some packagers (such as rpmbuild) and
kernel/module.c +30 -7
@@ -2753,8 +2753,9 @@ static inline void kmemleak_load_module(const struct module *mod,#ifdef CONFIG_MODULE_SIG static int module_sig_check (struct load_info *info,int flags) { -int err = -ENOKEY ; +int err = -ENODATA ;const unsigned long markerlen =sizeof (MODULE_SIG_STRING ) -1 ; +const char *reason;const void *mod = info->hdr;/*
@@ -2769,16 +2770,38 @@ 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; +return security_locked_down (LOCKDOWN_MODULE_SIGNATURE ); + +/* 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)
security/lockdown/Kconfig +1 -0
@@ -1,6 +1,7 @@ config SECURITY_LOCKDOWN_LSM bool "Basic module for enforcing kernel lockdown" depends on SECURITY + select MODULE_SIG if MODULES help Build support for an LSM that enforces a coarse kernel lockdown behaviour.
security/lockdown/lockdown.c +1 -0
@@ -18,6 +18,7 @@ static enum lockdown_reason kernel_locked_down;static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX +1 ] = { [LOCKDOWN_NONE ] ="none" , + [LOCKDOWN_MODULE_SIGNATURE ] ="unsigned module loading" , [LOCKDOWN_INTEGRITY_MAX ] ="integrity" , [LOCKDOWN_CONFIDENTIALITY_MAX ] ="confidentiality" , };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
David Howells
maintainerRe: [PATCH V40 04/29] lockdown: Enforce module signatures if the kernel is locked down
include/linux/security.h enum lsm_event { · line 109
Quoted 6 lines · Matthew Garrett
enum
lockdown_reason{include/linux/security.h +1
-0LOCKDOWN_NONE , +LOCKDOWN_MODULE_SIGNATURE ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
Aren't you mixing disjoint sets?
security/lockdown/lockdown.c static enum lockdown_reason kernel_locked_down; · line 21
Quoted 1 line
security/lockdown/lockdown.c +1
-0+ [LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
Wouldn't it be better to pass this string as a parameter to security_locked_down()?
David
Re: [PATCH V40 04/29] lockdown: Enforce module signatures if the kernel is locked down
Quoted 11 lines · David Howells
Quoted 6 lines · Matthew Garrett
enum
lockdown_reason{
LOCKDOWN_NONE,
+LOCKDOWN_MODULE_SIGNATURE,
LOCKDOWN_INTEGRITY_MAX,
LOCKDOWN_CONFIDENTIALITY_MAX,
};Aren't you mixing disjoint sets?
The goal is to be able to check whether any given lockdown reason is a matter of integrity or confidentiality in a straightforward way.
Quoted 4 lines
Quoted 1 line
+ [
LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",Wouldn't it be better to pass this string as a parameter to
security_locked_down()?
I thought about that, but it's not how any other LSM hooks behave. I think it's probably easier to revisit that when we see how other LSMs want to make use of the data.
PATCH v40 5/29 lockdown: 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 | 7 +++++-- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+), 2 deletions(-)
drivers/char/mem.c +5 -2
@@ -29,8 +29,8 @@#include <linux/export.h> #include <linux/io.h> #include <linux/uio.h> -#include <linux/uaccess.h> +#include <linux/security.h> #ifdef CONFIG_IA64 # include <linux/efi.h>
@@ -786,7 +786,10 @@ static loff_t memory_lseek(struct file *file, loff_t offset, int orig)static int open_port (struct inode *inode,struct file *filp) { -return capable (CAP_SYS_RAWIO ) ?0 : -EPERM ; +if (!capable (CAP_SYS_RAWIO )) +return -EPERM ; + +return security_locked_down (LOCKDOWN_DEV_MEM ); }#define zero_lseek null_lseek
include/linux/security.h +1 -0
@@ -104,6 +104,7 @@ enum lsm_event {enum lockdown_reason {LOCKDOWN_NONE ,LOCKDOWN_MODULE_SIGNATURE , +LOCKDOWN_DEV_MEM ,LOCKDOWN_INTEGRITY_MAX ,LOCKDOWN_CONFIDENTIALITY_MAX , };
security/lockdown/lockdown.c +1 -0
@@ -19,6 +19,7 @@ static enum lockdown_reason kernel_locked_down;static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX +1 ] = { [LOCKDOWN_NONE ] ="none" , [LOCKDOWN_MODULE_SIGNATURE ] ="unsigned module loading" , + [LOCKDOWN_DEV_MEM ] ="/dev/mem,kmem,port" , [LOCKDOWN_INTEGRITY_MAX ] ="integrity" , [LOCKDOWN_CONFIDENTIALITY_MAX ] ="confidentiality" , };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 6/29 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.
--- include/linux/security.h | 1 + kernel/kexec.c | 8 ++++++++ security/lockdown/lockdown.c | 1 + 3 files changed, 10 insertions(+)
include/linux/security.h +1 -0
@@ -105,6 +105,7 @@ enum lockdown_reason {LOCKDOWN_NONE ,LOCKDOWN_MODULE_SIGNATURE ,LOCKDOWN_DEV_MEM , +LOCKDOWN_KEXEC ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
kernel/kexec.c +8 -0
@@ -205,6 +205,14 @@ 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 +*/ + result =security_locked_down (LOCKDOWN_KEXEC ); +if (result) +return result; +/* * Verify we have a legal set of flags * This leaves us room for future extensions.
security/lockdown/lockdown.c +1 -0
@@ -20,6 +20,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_NONE] = "none", [LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading", [LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port", + [LOCKDOWN_KEXEC] = "kexec of unsigned images", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 7/29 lockdown: 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
@@ -180,6 +180,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.23.0.rc1.153.gdeed80330f-goog
PATCH v40 8/29 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.
--- arch/arm64/Kconfig | 6 +-- arch/s390/Kconfig | 2 +- arch/s390/configs/debug_defconfig | 2 +- arch/s390/configs/defconfig | 2 +- arch/s390/configs/performance_defconfig | 2 +- arch/s390/kernel/kexec_elf.c | 4 +- arch/s390/kernel/kexec_image.c | 4 +- arch/s390/kernel/machine_kexec_file.c | 4 +- arch/x86/Kconfig | 20 ++++++--- arch/x86/kernel/ima_arch.c | 4 +- crypto/asymmetric_keys/verify_pefile.c | 4 +- include/linux/kexec.h | 4 +- kernel/kexec_file.c | 60 +++++++++++++++++++++---- security/integrity/ima/Kconfig | 2 +- security/integrity/ima/ima_main.c | 2 +- 15 files changed, 88 insertions(+), 34 deletions(-)
arch/arm64/Kconfig +3 -3
@@ -961,7 +961,7 @@ config KEXEC_FILE for kernel and initramfs as opposed to list of segments as accepted by previous system call. -config KEXEC_VERIFY_SIG +config KEXEC_SIG bool "Verify kernel signature during kexec_file_load() syscall" depends on KEXEC_FILE help
@@ -976,13 +976,13 @@ config KEXEC_VERIFY_SIG config KEXEC_IMAGE_VERIFY_SIG bool "Enable Image signature verification support" default y - depends on KEXEC_VERIFY_SIG + depends on KEXEC_SIG depends on EFI && SIGNED_PE_FILE_VERIFICATION help Enable Image signature verification support. comment "Support for PE file signature verification disabled" - depends on KEXEC_VERIFY_SIG + depends on KEXEC_SIG depends on !EFI || !SIGNED_PE_FILE_VERIFICATION config CRASH_DUMP
arch/s390/Kconfig +1 -1
@@ -555,7 +555,7 @@ config ARCH_HAS_KEXEC_PURGATORY def_bool y depends on KEXEC_FILE -config KEXEC_VERIFY_SIG +config KEXEC_SIG bool "Verify kernel signature during kexec_file_load() syscall" depends on KEXEC_FILE && SYSTEM_DATA_VERIFICATION help
arch/s390/configs/debug_defconfig +1 -1
@@ -64,7 +64,7 @@ CONFIG_NUMA=y CONFIG_PREEMPT=y CONFIG_HZ_100=y CONFIG_KEXEC_FILE=y -CONFIG_KEXEC_VERIFY_SIG=y +CONFIG_KEXEC_SIG=y CONFIG_EXPOLINE=y CONFIG_EXPOLINE_AUTO=y CONFIG_MEMORY_HOTPLUG=y
arch/s390/configs/defconfig +1 -1
@@ -39,7 +39,7 @@ CONFIG_NR_CPUS=256 CONFIG_NUMA=y CONFIG_HZ_100=y CONFIG_KEXEC_FILE=y -CONFIG_KEXEC_VERIFY_SIG=y +CONFIG_KEXEC_SIG=y CONFIG_CRASH_DUMP=y CONFIG_HIBERNATION=y CONFIG_PM_DEBUG=y
arch/s390/configs/performance_defconfig +1 -1
@@ -65,7 +65,7 @@ CONFIG_NR_CPUS=512 CONFIG_NUMA=y CONFIG_HZ_100=y CONFIG_KEXEC_FILE=y -CONFIG_KEXEC_VERIFY_SIG=y +CONFIG_KEXEC_SIG=y CONFIG_EXPOLINE=y CONFIG_EXPOLINE_AUTO=y CONFIG_MEMORY_HOTPLUG=y
arch/s390/kernel/kexec_elf.c +2 -2
@@ -130,7 +130,7 @@ static int s390_elf_probe(const char *buf, unsigned long len)const struct kexec_file_ops s390_kexec_elf_ops = { .probe = s390_elf_probe, .load = s390_elf_load, -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC__SIG .verify_sig = s390_verify_sig, -#endif /* CONFIG_KEXEC_VERIFY_SIG */ +#endif /* CONFIG_KEXEC_SIG */ };
arch/s390/kernel/kexec_image.c +2 -2
@@ -59,7 +59,7 @@ static int s390_image_probe(const char *buf, unsigned long len)const struct kexec_file_ops s390_kexec_image_ops = { .probe = s390_image_probe, .load = s390_image_load, -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC_SIG .verify_sig = s390_verify_sig, -#endif /* CONFIG_KEXEC_VERIFY_SIG */ +#endif /* CONFIG_KEXEC_SIG */ };
arch/s390/kernel/machine_kexec_file.c +2 -2
@@ -22,7 +22,7 @@ const struct kexec_file_ops * const kexec_file_loaders[] = { NULL, }; -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC_SIG /* * Module signature information block. *
@@ -90,7 +90,7 @@ int s390_verify_sig(const char *kernel, unsigned long kernel_len)VERIFYING_MODULE_SIGNATURE , NULL, NULL); } -#endif /* CONFIG_KEXEC_VERIFY_SIG */ +#endif /* CONFIG_KEXEC_SIG */ static int kexec_file_update_purgatory (struct kimage *image,struct s390_load_data *data)
arch/x86/Kconfig +15 -5
@@ -2006,20 +2006,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---
arch/x86/kernel/ima_arch.c +2 -2
@@ -66,9 +66,9 @@ bool arch_ima_get_secureboot(void)/* secureboot arch rules */ static const char *const sb_arch_rules[] = { -#if !IS_ENABLED(CONFIG_KEXEC_VERIFY_SIG) +#if !IS_ENABLED(CONFIG_KEXEC_SIG)"appraise func=KEXEC_KERNEL_CHECK appraise_type=imasig" , -#endif /* CONFIG_KEXEC_VERIFY_SIG */ +#endif /* CONFIG_KEXEC_SIG */"measure func=KEXEC_KERNEL_CHECK" , #if !IS_ENABLED(CONFIG_MODULE_SIG) "appraise func=MODULE_CHECK appraise_type=imasig",
crypto/asymmetric_keys/verify_pefile.c +3 -1
@@ -96,7 +96,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,
@@ -403,6 +403,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 +51 -9
85 lines not on this page · raw message
security/integrity/ima/Kconfig +1 -1
@@ -160,7 +160,7 @@ config IMA_APPRAISE config IMA_ARCH_POLICY bool "Enable loading an IMA architecture specific policy" - depends on KEXEC_VERIFY_SIG || IMA_APPRAISE && INTEGRITY_ASYMMETRIC_KEYS + depends on KEXEC_SIG || IMA_APPRAISE && INTEGRITY_ASYMMETRIC_KEYS default n help This option enables loading an IMA architecture specific policy
security/integrity/ima/ima_main.c +1 -1
@@ -541,7 +541,7 @@ int ima_load_data(enum kernel_load_data_id id)switch (id) {case LOADING_KEXEC_IMAGE : -if (IS_ENABLED (CONFIG_KEXEC_VERIFY_SIG ) +if (IS_ENABLED (CONFIG_KEXEC_SIG ) &&arch_ima_get_secureboot ()) {pr_err ("impossible to appraise a kernel image without a file descriptor; try using kexec_file_load syscall.\n" );return -EACCES ;
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 08/29] kexec_file: split KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE
Hi Matthew,
found a typo ...
On Mon, 19 Aug 2019 17:17:44 -0700
Matthew Garrett <[email protected]> wrote:
[...]
arch/s390/kernel/kexec_elf.c static int s390_elf_probe(const char *buf, unsigned long len) · line 133
Quoted 9 lines
index
6d0635ceddd0..9b4f37a4edf1100644arch/s390/kernel/kexec_elf.c +1
-1@@ -130,7 +130,7 @@ static int s390_elf_probe(const char *buf, unsigned long len)const struct kexec_file_ops s390_kexec_elf_ops = { .probe = s390_elf_probe, .load = s390_elf_load, -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC__SIG
^^
... here.
arch/s390/kernel/kexec_elf.c static int s390_elf_probe(const char *buf, unsigned long len) · line 136
Quoted 4 lines
arch/s390/kernel/kexec_elf.c +1
-1.verify_sig = s390_verify_sig, -#endif /* CONFIG_KEXEC_VERIFY_SIG */ +#endif /* CONFIG_KEXEC_SIG */ };
Thanks
Philipp
PATCH v40 9/29 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.
[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. Modified by Matthew Garrett to remove the IMA integration, which will be replaced by integrating with the IMA architecture policy patches.]
--- kernel/kexec_file.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/kexec_file.c +1 -1
@@ -208,7 +208,7 @@ kimage_validate_signature(struct kimage *image)return ret; } -return 0 ; +return security_locked_down (LOCKDOWN_KEXEC );/* All other errors are fatal, including nomem, unparseable * signatures and signature check failures - even if signatures
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 10/29 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.
--- include/linux/security.h | 1 + kernel/power/hibernate.c | 3 ++- security/lockdown/lockdown.c | 1 + 3 files changed, 4 insertions(+), 1 deletion(-)
include/linux/security.h +1 -0
@@ -106,6 +106,7 @@ enum lockdown_reason {LOCKDOWN_MODULE_SIGNATURE ,LOCKDOWN_DEV_MEM ,LOCKDOWN_KEXEC , +LOCKDOWN_HIBERNATION ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
kernel/power/hibernate.c +2 -1
@@ -30,6 +30,7 @@#include <linux/ctype.h> #include <linux/genhd.h> #include <linux/ktime.h> +#include <linux/security.h> #include <trace/events/power.h> #include "power.h"
@@ -68,7 +69,7 @@ static const struct platform_hibernation_ops *hibernation_ops;bool hibernation_available (void ) { -return (nohibernate ==0 ); +return nohibernate ==0 && !security_locked_down (LOCKDOWN_HIBERNATION ); }/**
security/lockdown/lockdown.c +1 -0
@@ -21,6 +21,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading", [LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port", [LOCKDOWN_KEXEC] = "kexec of unsigned images", + [LOCKDOWN_HIBERNATION] = "hibernation", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 10/29] hibernate: Disable when the kernel is locked down
Quoted 7 lines · CEST 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.
Quoted 8 lines
Signed-off-by Josh Boyer <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by James Morris <[email protected]>
Quoted 52 lines
--- include/linux/security.h | 1 + kernel/power/hibernate.c | 3 ++- security/lockdown/lockdown.c | 1 + 3 files changed, 4 insertions(+), 1 deletion(-)include/linux/security.h +1
-0@@ -106,6 +106,7 @@ enum lockdown_reason {LOCKDOWN_MODULE_SIGNATURE ,LOCKDOWN_DEV_MEM ,LOCKDOWN_KEXEC , +LOCKDOWN_HIBERNATION ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };kernel/power/hibernate.c +2
-1@@ -30,6 +30,7 @@#include <linux/ctype.h> #include <linux/genhd.h> #include <linux/ktime.h> +#include <linux/security.h> #include <trace/events/power.h> #include "power.h" @@ -68,7 +69,7 @@ static const struct platform_hibernation_ops *hibernation_ops;bool hibernation_available (void ) { -return (nohibernate ==0 ); +return nohibernate ==0 && !security_locked_down (LOCKDOWN_HIBERNATION ); }/** security/lockdown/lockdown.c +1
-0@@ -21,6 +21,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading", [LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port", [LOCKDOWN_KEXEC] = "kexec of unsigned images", + [LOCKDOWN_HIBERNATION] = "hibernation", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Re: [PATCH V40 10/29] hibernate: Disable when the kernel is locked down
In reply to Matthew GarrettQuoted 7 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.
Quoted 8 lines
Signed-off-by Josh Boyer <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by James Morris <[email protected]>
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
PATCH v40 11/29 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 | 16 ++++++++++++++++ drivers/pci/proc.c | 14 ++++++++++++-- drivers/pci/syscall.c | 4 +++- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 5 files changed, 33 insertions(+), 3 deletions(-)
drivers/pci/pci-sysfs.c +16 -0
@@ -903,6 +903,11 @@ static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,unsigned int size = count;loff_t init_off = off;u8 *data = (u8 *) buf; +int ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret;if (off > dev->cfg_size)return 0 ;
@@ -1164,6 +1169,11 @@ static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,int bar = (unsigned long )attr->private;enum pci_mmap_state mmap_type;struct resource *res = &pdev->resource[bar]; +int ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret;if (res->flags &IORESOURCE_MEM &&iomem_is_exclusive (res->start))return -EINVAL ;
@@ -1240,6 +1250,12 @@ 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) { + int ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret; +return pci_resource_io (filp, kobj, attr, buf, off, count, true); }
drivers/pci/proc.c +12 -2
@@ -13,6 +13,7 @@#include <linux/seq_file.h> #include <linux/capability.h> #include <linux/uaccess.h> +#include <linux/security.h> #include <asm/byteorder.h> #include "pci.h"
@@ -115,7 +116,11 @@ static ssize_t proc_bus_pci_write(struct file *file, const char __user *buf,struct pci_dev *dev =PDE_DATA (ino);int pos = *ppos;int size = dev->cfg_size; -int cnt; +int cnt, ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret;if (pos >= size)return 0 ;
@@ -196,6 +201,10 @@ static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,#endif /* HAVE_PCI_MMAP */ int ret =0 ; + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret; +switch (cmd) {case PCIIOC_CONTROLLER : ret =pci_domain_nr (dev->bus);
@@ -238,7 +247,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 ) || +security_locked_down (LOCKDOWN_PCI_ACCESS ))return -EPERM ;if (fpriv->mmap_state == pci_mmap_io) {
drivers/pci/syscall.c +3 -1
@@ -7,6 +7,7 @@#include <linux/errno.h> #include <linux/pci.h> +#include <linux/security.h> #include <linux/syscalls.h> #include <linux/uaccess.h> #include "pci.h"
@@ -90,7 +91,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 ) || +security_locked_down (LOCKDOWN_PCI_ACCESS ))return -EPERM ; dev =pci_get_domain_bus_and_slot (0 , bus, dfn);
include/linux/security.h +1 -0
@@ -107,6 +107,7 @@ enum lockdown_reason {LOCKDOWN_DEV_MEM ,LOCKDOWN_KEXEC ,LOCKDOWN_HIBERNATION , +LOCKDOWN_PCI_ACCESS ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -22,6 +22,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port", [LOCKDOWN_KEXEC] = "kexec of unsigned images", [LOCKDOWN_HIBERNATION] = "hibernation", + [LOCKDOWN_PCI_ACCESS] = "direct PCI access", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 11/29] PCI: Lock down BAR access when the kernel is locked down
Quoted 8 lines · Matthew Garrett
From: 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.
Quoted 6 lines
Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Acked-by Bjorn Helgaas <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by James Morris <[email protected]>
Since I've acked this and it's 11/29, I've been assuming you intend to merge the whole series together. But the fact that it's up to V40 makes me wonder if you're waiting for me to merge this one. Just let me know either way.
Quoted 144 lines
--- drivers/pci/pci-sysfs.c | 16 ++++++++++++++++ drivers/pci/proc.c | 14 ++++++++++++-- drivers/pci/syscall.c | 4 +++- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 5 files changed, 33 insertions(+), 3 deletions(-)drivers/pci/pci-sysfs.c +16
-0@@ -903,6 +903,11 @@ static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,unsigned int size = count;loff_t init_off = off;u8 *data = (u8 *) buf; +int ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret;if (off > dev->cfg_size)return 0 ;@@ -1164,6 +1169,11 @@ static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,int bar = (unsigned long )attr->private;enum pci_mmap_state mmap_type;struct resource *res = &pdev->resource[bar]; +int ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret;if (res->flags &IORESOURCE_MEM &&iomem_is_exclusive (res->start))return -EINVAL ;@@ -1240,6 +1250,12 @@ 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) { + int ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret; +return pci_resource_io (filp, kobj, attr, buf, off, count, true); }drivers/pci/proc.c +12
-2@@ -13,6 +13,7 @@#include <linux/seq_file.h> #include <linux/capability.h> #include <linux/uaccess.h> +#include <linux/security.h> #include <asm/byteorder.h> #include "pci.h" @@ -115,7 +116,11 @@ static ssize_t proc_bus_pci_write(struct file *file, const char __user *buf,struct pci_dev *dev =PDE_DATA (ino);int pos = *ppos;int size = dev->cfg_size; -int cnt; +int cnt, ret; + + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret;if (pos >= size)return 0 ;@@ -196,6 +201,10 @@ static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,#endif /* HAVE_PCI_MMAP */ int ret =0 ; + ret =security_locked_down (LOCKDOWN_PCI_ACCESS ); +if (ret) +return ret; +switch (cmd) {case PCIIOC_CONTROLLER : ret =pci_domain_nr (dev->bus);@@ -238,7 +247,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 ) || +security_locked_down (LOCKDOWN_PCI_ACCESS ))return -EPERM ;if (fpriv->mmap_state == pci_mmap_io) {drivers/pci/syscall.c +3
-1@@ -7,6 +7,7 @@#include <linux/errno.h> #include <linux/pci.h> +#include <linux/security.h> #include <linux/syscalls.h> #include <linux/uaccess.h> #include "pci.h" @@ -90,7 +91,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 ) || +security_locked_down (LOCKDOWN_PCI_ACCESS ))return -EPERM ; dev =pci_get_domain_bus_and_slot (0 , bus, dfn);include/linux/security.h +1
-0@@ -107,6 +107,7 @@ enum lockdown_reason {LOCKDOWN_DEV_MEM ,LOCKDOWN_KEXEC ,LOCKDOWN_HIBERNATION , +LOCKDOWN_PCI_ACCESS ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };security/lockdown/lockdown.c +1
-0@@ -22,6 +22,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port", [LOCKDOWN_KEXEC] = "kexec of unsigned images", [LOCKDOWN_HIBERNATION] = "hibernation", + [LOCKDOWN_PCI_ACCESS] = "direct PCI access", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 11/29] PCI: Lock down BAR access when the kernel is locked down
Quoted 4 lines · Bjorn Helgaas
Since I've acked this and it's 11/29, I've been assuming you intend to merge the whole series together. But the fact that it's up to V40 makes me wonder if you're waiting for me to merge this one. Just let me know either way.
James has merged the series.
PATCH v40 12/29 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 | 7 +++++-- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+), 2 deletions(-)
arch/x86/kernel/ioport.c +5 -2
@@ -11,6 +11,7 @@#include <linux/errno.h> #include <linux/types.h> #include <linux/ioport.h> +#include <linux/security.h> #include <linux/smp.h> #include <linux/stddef.h> #include <linux/slab.h>
@@ -31,7 +32,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 ) || +security_locked_down (LOCKDOWN_IOPORT )))return -EPERM ;/*
@@ -126,7 +128,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 ) || +security_locked_down (LOCKDOWN_IOPORT ))return -EPERM ; } regs->flags = (regs->flags & ~X86_EFLAGS_IOPL) |
include/linux/security.h +1 -0
@@ -108,6 +108,7 @@ enum lockdown_reason {LOCKDOWN_KEXEC ,LOCKDOWN_HIBERNATION ,LOCKDOWN_PCI_ACCESS , +LOCKDOWN_IOPORT ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -23,6 +23,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_KEXEC] = "kexec of unsigned images", [LOCKDOWN_HIBERNATION] = "hibernation", [LOCKDOWN_PCI_ACCESS] = "direct PCI access", + [LOCKDOWN_IOPORT] = "raw io port access", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 12/29] x86: Lock down IO port access when the kernel is locked down
Hi Matthew,
Quoted 8 lines · Matthew Garrett
From: 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.
Quoted 8 lines
This also implicitly locks down the KDADDIO, KDDELIO, KDENABIO and KDDISABIO console ioctls.
Signed-off-by Matthew Garrett <[email protected]>Signed-off-by David Howells <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by James Morris <[email protected]>
This patch breaks ioperm() usage from userspace programs with CAP_SYS_RAWIO cap.
I wonder if it's possible to revert this commit?
Kai-Heng
Quoted 65 lines
--- arch/x86/kernel/ioport.c | 7 +++++-- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+), 2 deletions(-)arch/x86/kernel/ioport.c +5
-2@@ -11,6 +11,7 @@#include <linux/errno.h> #include <linux/types.h> #include <linux/ioport.h> +#include <linux/security.h> #include <linux/smp.h> #include <linux/stddef.h> #include <linux/slab.h> @@ -31,7 +32,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 ) || +security_locked_down (LOCKDOWN_IOPORT )))return -EPERM ;/* @@ -126,7 +128,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 ) || +security_locked_down (LOCKDOWN_IOPORT ))return -EPERM ; } regs->flags = (regs->flags & ~X86_EFLAGS_IOPL) |include/linux/security.h +1
-0@@ -108,6 +108,7 @@ enum lockdown_reason {LOCKDOWN_KEXEC ,LOCKDOWN_HIBERNATION ,LOCKDOWN_PCI_ACCESS , +LOCKDOWN_IOPORT ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };security/lockdown/lockdown.c +1
-1@@ -23,6 +23,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_KEXEC] = "kexec of unsigned images", [LOCKDOWN_HIBERNATION] = "hibernation", [LOCKDOWN_PCI_ACCESS] = "direct PCI access", + [LOCKDOWN_IOPORT] = "raw io port access", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", }; --2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 12/29] x86: Lock down IO port access when the kernel is locked down
Quoted 3 lines · Kai-Heng Feng
This patch breaks
ioperm()usage from userspace programs withCAP_SYS_RAWIOcap.I wonder if it's possible to revert this commit?
When lockdown is enabled, or under all circumstances? It's expected to be blocked when lockdown is enabled - allowing userland to use port IO would potentially allow reconfiguration of PCI devices in ways that could alter kernel behaviour in ways relevant to security, which is what lockdown aims to prevent. What's being broken by this?
Re: [PATCH V40 12/29] x86: Lock down IO port access when the kernel is locked down
Quoted 5 lines · Matthew Garrett
Quoted 2 lines · Kai-Heng Feng
This patch breaks
ioperm()usage from userspace programs withCAP_SYS_RAWIOcap.
Quoted 7 lines
Quoted 1 line
I wonder if it's possible to revert this commit?
When lockdown is enabled, or under all circumstances? It's expected to be blocked when lockdown is enabled - allowing userland to use port IO would potentially allow reconfiguration of PCI devices in ways that could alter kernel behaviour in ways relevant to security, which is what lockdown aims to prevent. What's being broken by this?
Only when lockdown is enabled.
The affected system from the customer has SecureBoot enabled (and hence lockdown), and the kernel upgrade surprisingly broke ioperm() usage.
The userspace program is proprietary so I can't share it here.
Basically this patch makes ioperm() a noop on SecureBoot enabled x86 systems. If reverting is not an option, what else can we do to circumvent the regression?
Kai-Heng
Re: [PATCH V40 12/29] x86: Lock down IO port access when the kernel is locked down
Quoted 3 lines · Kai-Heng Feng
The affected system from the customer has SecureBoot enabled (and hence lockdown), and the kernel upgrade surprisingly broke
ioperm()usage.
Which kernel was being used that was signed but didn't implement lockdown? That sounds, uh, bad.
Quoted 1 line
The userspace program is proprietary so I can't share it here.
Ok. Are you able to describe anything about what it does so we can figure out a better solution?
Quoted 2 lines
Basically this patch makes
ioperm()a noop on SecureBoot enabled x86 systems. If reverting is not an option, what else can we do to circumvent the regression?
There's two main choices:
1) Disable secure boot on the system in question - if there's a need to run userland that can do arbitrary port IO then secure boot isn't providing any meaningful security benefit in any case.
2) Implement a kernel driver that abstracts the hardware access away from userland, and ensures that all the accesses are performed in a safe way.
Doing port IO from userland is almost always a terrible idea - it usually involves indexed accesses (you write an address to one port and then write or read data from another), and if two processes are trying to do this simultaneously (either because SMP or because one process gets preempted after writing the address but before accessing the data register), and in that case you can end up with accesses to the wrong register as a result. You really want this sort of thing to be mediated by the kernel, both from a safety perspective and to ensure appropriate synchronisation.
Re: [PATCH V40 12/29] x86: Lock down IO port access when the kernel is locked down
Quoted 9 lines · Matthew Garrett
Quoted 3 lines · Kai-Heng Feng
The affected system from the customer has SecureBoot enabled (and hence lockdown), and the kernel upgrade surprisingly broke
ioperm()usage.Which kernel was being used that was signed but didn't implement lockdown? That sounds, uh, bad.
It was upgraded from older distro release. Older kernels don't have lockdown.
Quoted 6 lines
Quoted 2 lines
The userspace program is proprietary so I can't share it here.
Ok. Are you able to describe anything about what it does so we can figure out a better solution?
Quoted 8 lines
Quoted 2 lines
Basically this patch makes
ioperm()a noop on SecureBoot enabled x86 systems. If reverting is not an option, what else can we do to circumvent the regression?There's two main choices:
1) Disable secure boot on the system in question - if there's a need to run userland that can do arbitrary port IO then secure boot isn't providing any meaningful security benefit in any case.
How so?
Other security features are still incredible valuable, we don't want to toss them out just because someone has to use ioperm().
Quoted 5 lines
2) Implement a kernel driver that abstracts the hardware access away from userland, and ensures that all the accesses are performed in a safe way.
Quoted 9 lines
Doing port IO from userland is almost always a terrible idea - it usually involves indexed accesses (you write an address to one port and then write or read data from another), and if two processes are trying to do this simultaneously (either because SMP or because one process gets preempted after writing the address but before accessing the data register), and in that case you can end up with accesses to the wrong register as a result. You really want this sort of thing to be mediated by the kernel, both from a safety perspective and to ensure appropriate synchronisation.
Agree, let me start a discussion with them.
Kai-Heng
Re: [PATCH V40 12/29] x86: Lock down IO port access when the kernel is locked down
Quoted 4 lines · Kai-Heng Feng
Quoted 3 lines · Matthew Garrett
On Wed, Jan 05, 2022 at 02:57:57PM +0800, Kai-Heng Feng wrote:
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
The affected system from the customer has SecureBoot enabled (and hence lockdown), and the kernel upgrade surprisingly broke
ioperm()usage.Which kernel was being used that was signed but didn't implement lockdown? That sounds, uh, bad.
It was upgraded from older distro release. Older kernels don't have lockdown.
But have a signed bootloader? Which releases?
Quoted 9 lines
Quoted 5 lines
There's two main choices:
1) Disable secure boot on the system in question - if there's a need to run userland that can do arbitrary port IO then secure boot isn't providing any meaningful security benefit in any case.
How so?
Other security features are still incredible valuable, we don't want to toss them out just because someone has to useioperm().
Because having the ability to do port io allows you to tamper with the running kernel and disable all the other security boundaries, making them pointless. Many PCI devices have a port IO side channel into MMIO BARs for use in early boot, so if an attacker can fill that BAR as they wish and then modify the BAR to map it into the kernel address space (and fix up the bridges appropriately), or if the port IO interface can be used to trigger DMA, the outcomes are pretty bad. The point of lockdown is to disable every plausible interface for userland (even uid
0) to have access to any interfaces that would let them insert modified code into ring 0 - port IO is definitely one of those interfaces. An attacker could just take a kernel that allows ioperm(), add an initramfs containing their payload, boot, hotpatch the kernel to disable lockdown, and then kexec into their backdoored payload.
Quoted 15 lines
Quoted 5 lines
2) Implement a kernel driver that abstracts the hardware access away from userland, and ensures that all the accesses are performed in a safe way.
Quoted 9 lines
Doing port IO from userland is almost always a terrible idea - it usually involves indexed accesses (you write an address to one port and then write or read data from another), and if two processes are trying to do this simultaneously (either because SMP or because one process gets preempted after writing the address but before accessing the data register), and in that case you can end up with accesses to the wrong register as a result. You really want this sort of thing to be mediated by the kernel, both from a safety perspective and to ensure appropriate synchronisation.
Quoted 1 line
Agree, let me start a discussion with them.
Sounds good.
PATCH v40 13/29 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.
--- arch/x86/kernel/msr.c | 8 ++++++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 10 insertions(+)
arch/x86/kernel/msr.c +8 -0
@@ -34,6 +34,7 @@#include <linux/notifier.h> #include <linux/uaccess.h> #include <linux/gfp.h> +#include <linux/security.h> #include <asm/cpufeature.h> #include <asm/msr.h>
@@ -79,6 +80,10 @@ static ssize_t msr_write(struct file *file, const char __user *buf,int err =0 ;ssize_t bytes =0 ; + err =security_locked_down (LOCKDOWN_MSR ); +if (err) +return err; +if (count %8 )return -EINVAL ;/* Invalid chunk size */
@@ -130,6 +135,9 @@ static long msr_ioctl(struct file *file, unsigned int ioc, unsigned long arg) err = -EFAULT ;break ; } + err =security_locked_down (LOCKDOWN_MSR ); +if (err) +break ; err =wrmsr_safe_regs_on_cpu (cpu, regs);if (err)break ;
include/linux/security.h +1 -0
@@ -109,6 +109,7 @@ enum lockdown_reason {LOCKDOWN_HIBERNATION ,LOCKDOWN_PCI_ACCESS ,LOCKDOWN_IOPORT , +LOCKDOWN_MSR ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -24,6 +24,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_HIBERNATION] = "hibernation", [LOCKDOWN_PCI_ACCESS] = "direct PCI access", [LOCKDOWN_IOPORT] = "raw io port access", + [LOCKDOWN_MSR] = "raw MSR access", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 14/29 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 | 6 ++++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 8 insertions(+)
drivers/acpi/custom_method.c +6 -0
@@ -9,6 +9,7 @@#include <linux/uaccess.h> #include <linux/debugfs.h> #include <linux/acpi.h> +#include <linux/security.h> #include "internal.h"
@@ -29,6 +30,11 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,struct acpi_table_header table;acpi_status status; +int ret; + + ret =security_locked_down (LOCKDOWN_ACPI_TABLES ); +if (ret) +return ret;if (!(*ppos)) {/* parse the table header to get the table length */
include/linux/security.h +1 -0
@@ -110,6 +110,7 @@ enum lockdown_reason {LOCKDOWN_PCI_ACCESS ,LOCKDOWN_IOPORT ,LOCKDOWN_MSR , +LOCKDOWN_ACPI_TABLES ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -25,6 +25,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_PCI_ACCESS] = "direct PCI access", [LOCKDOWN_IOPORT] = "raw io port access", [LOCKDOWN_MSR] = "raw MSR access", + [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 14/29] ACPI: Limit access to custom_method when the kernel is locked down
Quoted 11 lines · CEST Matthew Garrett
From: Matthew Garrett <[email protected]>
custom_methodeffectively 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.Signed-off-by Matthew Garrett <[email protected]>Signed-off-by David Howells <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by James Morris <[email protected]>
Quoted 55 lines
--- drivers/acpi/custom_method.c | 6 ++++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 8 insertions(+)drivers/acpi/custom_method.c +6
-0@@ -9,6 +9,7 @@#include <linux/uaccess.h> #include <linux/debugfs.h> #include <linux/acpi.h> +#include <linux/security.h> #include "internal.h" @@ -29,6 +30,11 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,struct acpi_table_header table;acpi_status status; +int ret; + + ret =security_locked_down (LOCKDOWN_ACPI_TABLES ); +if (ret) +return ret;if (!(*ppos)) {/* parse the table header to get the table length */ include/linux/security.h +1
-0@@ -110,6 +110,7 @@ enum lockdown_reason {LOCKDOWN_PCI_ACCESS ,LOCKDOWN_IOPORT ,LOCKDOWN_MSR , +LOCKDOWN_ACPI_TABLES ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };security/lockdown/lockdown.c +1
-0@@ -25,6 +25,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_PCI_ACCESS] = "direct PCI access", [LOCKDOWN_IOPORT] = "raw io port access", [LOCKDOWN_MSR] = "raw MSR access", + [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
PATCH v40 15/29 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. This requires some reworking of the existing RSDP command line logic, since the early boot code also makes use of a command-line passed RSDP when locating the SRAT table before the lockdown code has been initialised. This is achieved by separating the command line RSDP path in the early boot code from the generic RSDP path, and then copying the command line RSDP into boot params in the kernel proper if lockdown is not enabled. If lockdown is enabled and an RSDP is provided on the command line, this will only be used when parsing SRAT (which shouldn't permit kernel code execution) and will be ignored in the rest of the kernel.
(Modified by Matthew Garrett in order to handle the early boot RSDP environment)
--- arch/x86/boot/compressed/acpi.c | 19 +++++++++++++------ arch/x86/include/asm/acpi.h | 9 +++++++++ arch/x86/include/asm/x86_init.h | 2 ++ arch/x86/kernel/acpi/boot.c | 5 +++++ arch/x86/kernel/x86_init.c | 1 + drivers/acpi/osl.c | 14 +++++++++++++- include/linux/acpi.h | 6 ++++++ 7 files changed, 49 insertions(+), 7 deletions(-)
arch/x86/boot/compressed/acpi.c +13 -6
@@ -26,7 +26,7 @@ struct mem_vector immovable_mem[MAX_NUMNODES*2];*/ #define MAX_ADDR_LEN 19 -static acpi_physical_address get_acpi_rsdp (void ) +static acpi_physical_address get_cmdline_acpi_rsdp (void ) {acpi_physical_address addr =0 ;
@@ -215,10 +215,7 @@ acpi_physical_address get_rsdp_addr(void) {acpi_physical_address pa; - pa =get_acpi_rsdp (); - -if (!pa) - pa = boot_params->acpi_rsdp_addr; + pa = boot_params->acpi_rsdp_addr;if (!pa) pa =efi_get_rsdp_addr ();
@@ -240,7 +237,17 @@ static unsigned long get_acpi_srat_table(void)char arg[10 ];u8 *entry; - rsdp = (struct acpi_table_rsdp *)(long )boot_params->acpi_rsdp_addr; +/* +* Check whether we were given an RSDP on the command line. We don't +* stash this in boot params because the kernel itself may have +* different ideas about whether to trust a command-line parameter. +*/ + rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp (); + +if (!rsdp) + rsdp = (struct acpi_table_rsdp *)(long ) + boot_params->acpi_rsdp_addr; +if (!rsdp)return 0 ;
arch/x86/include/asm/acpi.h +9 -0
@@ -117,6 +117,12 @@ static inline bool acpi_has_cpu_in_madt(void)return !!acpi_lapic; } +#define ACPI_HAVE_ARCH_SET_ROOT_POINTER +static inline void acpi_arch_set_root_pointer (u64 addr) +{ + x86_init.acpi.set_root_pointer (addr); +} +#define ACPI_HAVE_ARCH_GET_ROOT_POINTER static inline u64 acpi_arch_get_root_pointer (void ) {
@@ -125,6 +131,7 @@ static inline u64 acpi_arch_get_root_pointer(void)void acpi_generic_reduced_hw_init (void ); +void x86_default_set_root_pointer (u64 addr);u64 x86_default_get_root_pointer (void );#else /* !CONFIG_ACPI */
@@ -138,6 +145,8 @@ static inline void disable_acpi(void) { }static inline void acpi_generic_reduced_hw_init (void ) { } +static inline void x86_default_set_root_pointer (u64 addr) { } +static inline u64 x86_default_get_root_pointer (void ) {return 0 ;
arch/x86/include/asm/x86_init.h +2 -0
@@ -134,10 +134,12 @@ struct x86_hyper_init {/** * struct x86_init_acpi - x86 ACPI init functions +* @set_root_poitner: set RSDP address * @get_root_pointer: get RSDP address * @reduced_hw_early_init: hardware reduced platform early init */ struct x86_init_acpi { +void (*set_root_pointer)(u64 addr);u64 (*get_root_pointer)(void );void (*reduced_hw_early_init)(void ); };
arch/x86/kernel/acpi/boot.c +5 -0
@@ -1760,6 +1760,11 @@ void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)e820__update_table_print (); } +void x86_default_set_root_pointer (u64 addr) +{ + boot_params.acpi_rsdp_addr = addr; +} +u64 x86_default_get_root_pointer (void ) {return boot_params.acpi_rsdp_addr;
arch/x86/kernel/x86_init.c +1 -0
@@ -95,6 +95,7 @@ struct x86_init_ops x86_init __initdata = { }, .acpi = { + .set_root_pointer = x86_default_set_root_pointer, .get_root_pointer = x86_default_get_root_pointer, .reduced_hw_early_init = acpi_generic_reduced_hw_init, },
drivers/acpi/osl.c +13 -1
@@ -26,6 +26,7 @@#include <linux/list.h> #include <linux/jiffies.h> #include <linux/semaphore.h> +#include <linux/security.h> #include <asm/io.h> #include <linux/uaccess.h>
@@ -180,8 +181,19 @@ acpi_physical_address __init acpi_os_get_root_pointer(void)acpi_physical_address pa;#ifdef CONFIG_KEXEC -if (acpi_rsdp) +/* +* We may have been provided with an RSDP on the command line, +* but if a malicious user has done so they may be pointing us +* at modified ACPI tables that could alter kernel behaviour - +* so, we check the lockdown status before making use of +* it. If we trust it then also stash it in an architecture +* specific location (if appropriate) so it can be carried +* over further kexec()s. +*/ +if (acpi_rsdp && !security_locked_down (LOCKDOWN_ACPI_TABLES )) { +acpi_arch_set_root_pointer (acpi_rsdp);return acpi_rsdp; + }#endif pa =acpi_arch_get_root_pointer ();if (pa)
include/linux/acpi.h +6 -0
@@ -632,6 +632,12 @@ bool acpi_gtdt_c3stop(int type);int acpi_arch_timer_mem_init (struct arch_timer_mem *timer_mem,int *timer_count);#endif +#ifndef ACPI_HAVE_ARCH_SET_ROOT_POINTER +static inline void acpi_arch_set_root_pointer (u64 addr) +{ +} +#endif +#ifndef ACPI_HAVE_ARCH_GET_ROOT_POINTER static inline u64 acpi_arch_get_root_pointer (void ) {
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 15/29] acpi: Ignore acpi_rsdp kernel param when the kernel has been locked down
Quoted 18 lines · CEST Matthew Garrett
From: 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. This requires some reworking of the existing RSDP command line logic, since the early boot code also makes use of a command-line passed RSDP when locating the SRAT table before the lockdown code has been initialised. This is achieved by separating the command line RSDP path in the early boot code from the generic RSDP path, and then copying the command line RSDP into boot params in the kernel proper if lockdown is not enabled. If lockdown is enabled and an RSDP is provided on the command line, this will only be used when parsing SRAT (which shouldn't permit kernel code execution) and will be ignored in the rest of the kernel.
(Modified by Matthew Garrett in order to handle the early boot RSDP environment)
Quoted 7 lines
Signed-off-by Josh Boyer <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Reviewed-by Kees Cook <[email protected]>cc Dave Young <[email protected]>Signed-off-by James Morris <[email protected]>
Quoted 184 lines
--- arch/x86/boot/compressed/acpi.c | 19 +++++++++++++------ arch/x86/include/asm/acpi.h | 9 +++++++++ arch/x86/include/asm/x86_init.h | 2 ++ arch/x86/kernel/acpi/boot.c | 5 +++++ arch/x86/kernel/x86_init.c | 1 + drivers/acpi/osl.c | 14 +++++++++++++- include/linux/acpi.h | 6 ++++++ 7 files changed, 49 insertions(+), 7 deletions(-)arch/x86/boot/compressed/acpi.c +13
-6@@ -26,7 +26,7 @@ struct mem_vector immovable_mem[MAX_NUMNODES*2];*/ #define MAX_ADDR_LEN 19 -static acpi_physical_address get_acpi_rsdp (void ) +static acpi_physical_address get_cmdline_acpi_rsdp (void ) {acpi_physical_address addr =0 ;@@ -215,10 +215,7 @@ acpi_physical_address get_rsdp_addr(void) {acpi_physical_address pa; - pa =get_acpi_rsdp (); - -if (!pa) - pa = boot_params->acpi_rsdp_addr; + pa = boot_params->acpi_rsdp_addr;if (!pa) pa =efi_get_rsdp_addr ();@@ -240,7 +237,17 @@ static unsigned long get_acpi_srat_table(void)char arg[10 ];u8 *entry; - rsdp = (struct acpi_table_rsdp *)(long )boot_params->acpi_rsdp_addr; +/* +* Check whether we were given an RSDP on the command line. We don't +* stash this in boot params because the kernel itself may have +* different ideas about whether to trust a command-line parameter. +*/ + rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp (); + +if (!rsdp) + rsdp = (struct acpi_table_rsdp *)(long ) + boot_params->acpi_rsdp_addr; +if (!rsdp)return 0 ;arch/x86/include/asm/acpi.h +9
-0@@ -117,6 +117,12 @@ static inline bool acpi_has_cpu_in_madt(void)return !!acpi_lapic; } +#define ACPI_HAVE_ARCH_SET_ROOT_POINTER +static inline void acpi_arch_set_root_pointer (u64 addr) +{ + x86_init.acpi.set_root_pointer (addr); +} +#define ACPI_HAVE_ARCH_GET_ROOT_POINTER static inline u64 acpi_arch_get_root_pointer (void ) {@@ -125,6 +131,7 @@ static inline u64 acpi_arch_get_root_pointer(void)void acpi_generic_reduced_hw_init (void ); +void x86_default_set_root_pointer (u64 addr);u64 x86_default_get_root_pointer (void );#else /* !CONFIG_ACPI */ @@ -138,6 +145,8 @@ static inline void disable_acpi(void) { }static inline void acpi_generic_reduced_hw_init (void ) { } +static inline void x86_default_set_root_pointer (u64 addr) { } +static inline u64 x86_default_get_root_pointer (void ) {return 0 ;arch/x86/include/asm/x86_init.h +2
-0@@ -134,10 +134,12 @@ struct x86_hyper_init {/** * struct x86_init_acpi - x86 ACPI init functions +* @set_root_poitner: set RSDP address * @get_root_pointer: get RSDP address * @reduced_hw_early_init: hardware reduced platform early init */ struct x86_init_acpi { +void (*set_root_pointer)(u64 addr);u64 (*get_root_pointer)(void );void (*reduced_hw_early_init)(void ); };arch/x86/kernel/acpi/boot.c +5
-0@@ -1760,6 +1760,11 @@ void __init arch_reserve_mem_area(acpi_physical_address addr, size_t size)e820__update_table_print (); } +void x86_default_set_root_pointer (u64 addr) +{ + boot_params.acpi_rsdp_addr = addr; +} +u64 x86_default_get_root_pointer (void ) {return boot_params.acpi_rsdp_addr;arch/x86/kernel/x86_init.c +1
-0@@ -95,6 +95,7 @@ struct x86_init_ops x86_init __initdata = { }, .acpi = { + .set_root_pointer = x86_default_set_root_pointer, .get_root_pointer = x86_default_get_root_pointer, .reduced_hw_early_init = acpi_generic_reduced_hw_init, },drivers/acpi/osl.c +13
-1@@ -26,6 +26,7 @@#include <linux/list.h> #include <linux/jiffies.h> #include <linux/semaphore.h> +#include <linux/security.h> #include <asm/io.h> #include <linux/uaccess.h> @@ -180,8 +181,19 @@ acpi_physical_address __init acpi_os_get_root_pointer(void)acpi_physical_address pa;#ifdef CONFIG_KEXEC -if (acpi_rsdp) +/* +* We may have been provided with an RSDP on the command line, +* but if a malicious user has done so they may be pointing us +* at modified ACPI tables that could alter kernel behaviour - +* so, we check the lockdown status before making use of +* it. If we trust it then also stash it in an architecture +* specific location (if appropriate) so it can be carried +* over further kexec()s. +*/ +if (acpi_rsdp && !security_locked_down (LOCKDOWN_ACPI_TABLES )) { +acpi_arch_set_root_pointer (acpi_rsdp);return acpi_rsdp; + }#endif pa =acpi_arch_get_root_pointer ();if (pa)include/linux/acpi.h +6
-0@@ -632,6 +632,12 @@ bool acpi_gtdt_c3stop(int type);int acpi_arch_timer_mem_init (struct arch_timer_mem *timer_mem,int *timer_count);#endif +#ifndef ACPI_HAVE_ARCH_SET_ROOT_POINTER +static inline void acpi_arch_set_root_pointer (u64 addr) +{ +} +#endif +#ifndef ACPI_HAVE_ARCH_GET_ROOT_POINTER static inline u64 acpi_arch_get_root_pointer (void ) {
PATCH v40 16/29 acpi: Disable ACPI table override if the kernel is locked down
In reply to Matthew GarrettFrom: Linn Crosetto <[email protected]>
Quoted 1 line
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 lockdown is enabled, 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 | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/acpi/tables.c +6 -0
@@ -20,6 +20,7 @@#include <linux/memblock.h> #include <linux/earlycpio.h> #include <linux/initrd.h> +#include <linux/security.h> #include "internal.h" #ifdef CONFIG_ACPI_CUSTOM_DSDT
@@ -577,6 +578,11 @@ void __init acpi_table_upgrade(void)if (table_nr ==0 )return ; +if (security_locked_down (LOCKDOWN_ACPI_TABLES )) { +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.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 16/29] acpi: Disable ACPI table override if the kernel is locked down
Quoted 12 lines · CEST Matthew Garrett
From: Linn Crosetto <[email protected]>
Quoted 1 line
From the kernel documentation (initrd_table_override.txt):
If the
ACPI_INITRD_TABLE_OVERRIDEcompile option is true, it is possible to override nearly any ACPI table provided by the BIOS with an instrumented, modified one.When lockdown is enabled, 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.
Quoted 6 lines
Signed-off-by Linn Crosetto <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by James Morris <[email protected]>
Quoted 29 lines
--- drivers/acpi/tables.c | 6 ++++++ 1 file changed, 6 insertions(+)drivers/acpi/tables.c +6
-0@@ -20,6 +20,7 @@#include <linux/memblock.h> #include <linux/earlycpio.h> #include <linux/initrd.h> +#include <linux/security.h> #include "internal.h" #ifdef CONFIG_ACPI_CUSTOM_DSDT @@ -577,6 +578,11 @@ void __init acpi_table_upgrade(void)if (table_nr ==0 )return ; +if (security_locked_down (LOCKDOWN_ACPI_TABLES )) { +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 );
PATCH v40 17/29 lockdown: 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 | 5 +++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+)
drivers/pcmcia/cistpl.c +5 -0
@@ -21,6 +21,7 @@#include <linux/pci.h> #include <linux/ioport.h> #include <linux/io.h> +#include <linux/security.h> #include <asm/byteorder.h> #include <asm/unaligned.h>
@@ -1575,6 +1576,10 @@ static ssize_t pccard_store_cis(struct file *filp, struct kobject *kobj,struct pcmcia_socket *s;int error; + error =security_locked_down (LOCKDOWN_PCMCIA_CIS ); +if (error) +return error; + s = to_socket(container_of(kobj, struct device, kobj));if (off)
include/linux/security.h +1 -0
@@ -111,6 +111,7 @@ enum lockdown_reason {LOCKDOWN_IOPORT ,LOCKDOWN_MSR ,LOCKDOWN_ACPI_TABLES , +LOCKDOWN_PCMCIA_CIS ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -26,6 +26,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_IOPORT] = "raw io port access", [LOCKDOWN_MSR] = "raw MSR access", [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables", + [LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 18/29 lockdown: 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 | 5 +++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+)
drivers/tty/serial/serial_core.c +5 -0
@@ -22,6 +22,7 @@#include <linux/serial_core.h> #include <linux/delay.h> #include <linux/mutex.h> +#include <linux/security.h> #include <linux/irq.h> #include <linux/uaccess.h>
@@ -862,6 +863,10 @@ static int uart_set_info(struct tty_struct *tty, struct tty_port *port, goto check_and_exit; } + retval =security_locked_down (LOCKDOWN_TIOCSSERIAL ); +if (retval && (change_irq || change_port)) + goto exit; +/* * Ask the low level driver to verify the settings. */
include/linux/security.h +1 -0
@@ -112,6 +112,7 @@ enum lockdown_reason {LOCKDOWN_MSR ,LOCKDOWN_ACPI_TABLES ,LOCKDOWN_PCMCIA_CIS , +LOCKDOWN_TIOCSSERIAL ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -27,6 +27,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_MSR] = "raw MSR access", [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables", [LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage", + [LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 19/29 lockdown: 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).
--- include/linux/security.h | 1 + kernel/params.c | 21 ++++++++++++++++----- security/lockdown/lockdown.c | 1 + 3 files changed, 18 insertions(+), 5 deletions(-)
include/linux/security.h +1 -0
@@ -113,6 +113,7 @@ enum lockdown_reason {LOCKDOWN_ACPI_TABLES ,LOCKDOWN_PCMCIA_CIS ,LOCKDOWN_TIOCSSERIAL , +LOCKDOWN_MODULE_PARAMETERS ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
kernel/params.c +16 -5
@@ -12,6 +12,7 @@#include <linux/err.h> #include <linux/slab.h> #include <linux/ctype.h> +#include <linux/security.h> #ifdef CONFIG_SYSFS /* Protects all built-in parameters, modules use their own param_lock */
@@ -96,13 +97,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) { +if (kp->flags &KERNEL_PARAM_FL_HWPARAM && +security_locked_down (LOCKDOWN_MODULE_PARAMETERS )) +return false; +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 ); } + +return true; } static int parse_one(char *param,
@@ -132,8 +139,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])) + err = params[i].ops->set (val, ¶ms[i]); +else + err = -EPERM ;kernel_param_unlock (params[i].mod);return err; }
@@ -553,8 +562,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)) + err = attribute->param->ops->set (buf, attribute->param); +else + err = -EPERM ;kernel_param_unlock (mk->mod);if (!err)return len;
security/lockdown/lockdown.c +1 -0
@@ -28,6 +28,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables", [LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage", [LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO", + [LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
Re: [PATCH V40 19/29] lockdown: Lock down module params that specify hardware parameters (eg. ioport)
+++ Matthew Garrett [19/08/19 17:17 -0700]:
Quoted 6 lines
From: 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).
Quoted 6 lines
Suggested-by Alan Cox <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Reviewed-by Kees Cook <[email protected]>Cc Jessica Yu <[email protected]>Signed-off-by James Morris <[email protected]>
Thanks!
Quoted 92 lines
---
include/linux/security.h | 1 + kernel/params.c | 21 ++++++++++++++++----- security/lockdown/lockdown.c | 1 + 3 files changed, 18 insertions(+), 5 deletions(-)include/linux/security.h +1
-0@@ -113,6 +113,7 @@ enum lockdown_reason {LOCKDOWN_ACPI_TABLES ,LOCKDOWN_PCMCIA_CIS ,LOCKDOWN_TIOCSSERIAL , +LOCKDOWN_MODULE_PARAMETERS ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };kernel/params.c +16
-5@@ -12,6 +12,7 @@#include <linux/err.h> #include <linux/slab.h> #include <linux/ctype.h> +#include <linux/security.h> #ifdef CONFIG_SYSFS /* Protects all built-in parameters, modules use their own param_lock */ @@ -96,13 +97,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) { +if (kp->flags &KERNEL_PARAM_FL_HWPARAM && +security_locked_down (LOCKDOWN_MODULE_PARAMETERS )) +return false; +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 ); } + +return true; } static int parse_one(char *param,@@ -132,8 +139,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])) + err = params[i].ops->set (val, ¶ms[i]); +else + err = -EPERM ;kernel_param_unlock (params[i].mod);return err; }@@ -553,8 +562,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)) + err = attribute->param->ops->set (buf, attribute->param); +else + err = -EPERM ;kernel_param_unlock (mk->mod);if (!err)return len;security/lockdown/lockdown.c +1
-0@@ -28,6 +28,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_ACPI_TABLES] = "modifying ACPI tables", [LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage", [LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO", + [LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 20/29 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. This is a runtime check rather than buildtime in order to allow configurations where the same kernel may be run in both locked down or permissive modes depending on local policy.
--- arch/x86/mm/testmmiotrace.c | 5 +++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+)
arch/x86/mm/testmmiotrace.c +5 -0
@@ -8,6 +8,7 @@#include <linux/module.h> #include <linux/io.h> #include <linux/mmiotrace.h> +#include <linux/security.h> static unsigned long mmio_address;module_param_hw (mmio_address, ulong, iomem,0 );
@@ -115,6 +116,10 @@ static void do_test_bulk_ioremapping(void)static int __init init (void ) {unsigned long size = (read_far) ? (8 <<20 ) : (16 <<10 ); +int ret =security_locked_down (LOCKDOWN_MMIOTRACE ); + +if (ret) +return ret;if (mmio_address ==0 ) {pr_err ("you have to use the module argument mmio_address.\n" );
include/linux/security.h +1 -0
@@ -114,6 +114,7 @@ enum lockdown_reason {LOCKDOWN_PCMCIA_CIS ,LOCKDOWN_TIOCSSERIAL ,LOCKDOWN_MODULE_PARAMETERS , +LOCKDOWN_MMIOTRACE ,LOCKDOWN_INTEGRITY_MAX , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -29,6 +29,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage", [LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO", [LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters", + [LOCKDOWN_MMIOTRACE] = "unsafe mmio", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 21/29 lockdown: 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. This is limited to lockdown confidentiality mode and is still permitted in integrity mode.
--- fs/proc/kcore.c | 5 +++++ include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+)
fs/proc/kcore.c +5 -0
@@ -31,6 +31,7 @@#include <linux/ioport.h> #include <linux/memory.h> #include <linux/sched/task.h> +#include <linux/security.h> #include <asm/sections.h> #include "internal.h"
@@ -545,6 +546,10 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)static int open_kcore (struct inode *inode,struct file *filp) { +int ret =security_locked_down (LOCKDOWN_KCORE ); + +if (ret) +return ret;if (!capable (CAP_SYS_RAWIO ))return -EPERM ;
include/linux/security.h +1 -0
@@ -116,6 +116,7 @@ enum lockdown_reason {LOCKDOWN_MODULE_PARAMETERS ,LOCKDOWN_MMIOTRACE ,LOCKDOWN_INTEGRITY_MAX , +LOCKDOWN_KCORE , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -31,6 +31,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters", [LOCKDOWN_MMIOTRACE] = "unsafe mmio", [LOCKDOWN_INTEGRITY_MAX] = "integrity", + [LOCKDOWN_KCORE] = "/proc/kcore access", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 22/29 lockdown: Lock down tracing and perf kprobes when in confidentiality mode
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow the creation of perf and ftrace kprobes when the kernel is locked down in confidentiality mode by preventing their registration. This prevents kprobes from being used to access kernel memory to steal crypto data, but continues to allow the use of kprobes from signed modules.
--- include/linux/security.h | 1 + kernel/trace/trace_kprobe.c | 5 +++++ security/lockdown/lockdown.c | 1 + 3 files changed, 7 insertions(+)
include/linux/security.h +1 -0
@@ -117,6 +117,7 @@ enum lockdown_reason {LOCKDOWN_MMIOTRACE ,LOCKDOWN_INTEGRITY_MAX ,LOCKDOWN_KCORE , +LOCKDOWN_KPROBES , LOCKDOWN_CONFIDENTIALITY_MAX, };
kernel/trace/trace_kprobe.c +5 -0
@@ -11,6 +11,7 @@#include <linux/uaccess.h> #include <linux/rculist.h> #include <linux/error-injection.h> +#include <linux/security.h> #include "trace_dynevent.h" #include "trace_kprobe_selftest.h"
@@ -415,6 +416,10 @@ static int __register_trace_kprobe(struct trace_kprobe *tk) {int i, ret; + ret =security_locked_down (LOCKDOWN_KPROBES ); +if (ret) +return ret; +if (trace_probe_is_registered (&tk->tp))return -EINVAL ;
security/lockdown/lockdown.c +1 -0
@@ -32,6 +32,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_MMIOTRACE] = "unsafe mmio", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_KCORE] = "/proc/kcore access", + [LOCKDOWN_KPROBES] = "use of kprobes", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 23/29 bpf: Restrict bpf when kernel lockdown is in confidentiality mode
In reply to Matthew GarrettFrom: David Howells <[email protected]>
bpf_read() and bpf_read_str() could potentially be abused to (eg) allow private keys in kernel memory to be leaked. Disable them if the kernel has been locked down in confidentiality mode.
--- include/linux/security.h | 1 + kernel/trace/bpf_trace.c | 10 ++++++++++ security/lockdown/lockdown.c | 1 + 3 files changed, 12 insertions(+)
include/linux/security.h +1 -0
@@ -118,6 +118,7 @@ enum lockdown_reason {LOCKDOWN_INTEGRITY_MAX ,LOCKDOWN_KCORE ,LOCKDOWN_KPROBES , +LOCKDOWN_BPF_READ , LOCKDOWN_CONFIDENTIALITY_MAX, };
kernel/trace/bpf_trace.c +10 -0
@@ -139,8 +139,13 @@ BPF_CALL_3(bpf_probe_read, void *, dst, u32, size, const void *, unsafe_ptr) {int ret; + ret =security_locked_down (LOCKDOWN_BPF_READ ); +if (ret <0 ) + goto out; + ret =probe_kernel_read (dst, unsafe_ptr, size);if (unlikely (ret <0 )) +out:memset (dst,0 , size);return ret;
@@ -566,6 +571,10 @@ BPF_CALL_3(bpf_probe_read_str, void *, dst, u32, size, {int ret; + ret =security_locked_down (LOCKDOWN_BPF_READ ); +if (ret <0 ) + goto out; +/* * The strncpy_from_unsafe() call will likely not fill the entire * buffer, but that's okay in this circumstance as we're probing
@@ -577,6 +586,7 @@ BPF_CALL_3(bpf_probe_read_str, void *, dst, u32, size,*/ ret =strncpy_from_unsafe (dst, unsafe_ptr, size);if (unlikely (ret <0 )) +out:memset (dst,0 , size);return ret;
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_KCORE] = "/proc/kcore access", [LOCKDOWN_KPROBES] = "use of kprobes", + [LOCKDOWN_BPF_READ] = "use of bpf to read kernel RAM", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
David Howells
maintainerRe: [PATCH V40 23/29] bpf: Restrict bpf when kernel lockdown is in confidentiality mode
Quoted 6 lines · Matthew Garrett
From: David Howells <[email protected]>
bpf_read()andbpf_read_str()could potentially be abused to (eg) allow private keys in kernel memory to be leaked. Disable them if the kernel has been locked down in confidentiality mode.
Quoted 8 lines
Suggested-by Alexei Starovoitov <[email protected]>Signed-off-by Matthew Garrett <[email protected]>Reviewed-by Kees Cook <[email protected]>cc Chun-Yi Lee <[email protected]>cc Alexei Starovoitov <[email protected]>Cc Daniel Borkmann <[email protected]>Signed-off-by James Morris <[email protected]>
PATCH v40 24/29 lockdown: Lock down perf when in confidentiality mode
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow the use of certain perf facilities that might allow userspace to access kernel data.
--- include/linux/security.h | 1 + kernel/events/core.c | 7 +++++++ security/lockdown/lockdown.c | 1 + 3 files changed, 9 insertions(+)
include/linux/security.h +1 -0
@@ -119,6 +119,7 @@ enum lockdown_reason {LOCKDOWN_KCORE ,LOCKDOWN_KPROBES ,LOCKDOWN_BPF_READ , +LOCKDOWN_PERF , LOCKDOWN_CONFIDENTIALITY_MAX, };
kernel/events/core.c +7 -0
@@ -10798,6 +10798,13 @@ SYSCALL_DEFINE5(perf_event_open, perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))return -EACCES ; + err =security_locked_down (LOCKDOWN_PERF ); +if (err && (attr.sample_type &PERF_SAMPLE_REGS_INTR )) +/* REGS_INTR can leak data, lockdown must prevent this */ +return err; + + err =0 ; +/* * In cgroup mode, the pid argument is used to pass the fd * opened to the cgroup directory in cgroupfs. The cpu argument
security/lockdown/lockdown.c +1 -0
@@ -34,6 +34,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_KCORE] = "/proc/kcore access", [LOCKDOWN_KPROBES] = "use of kprobes", [LOCKDOWN_BPF_READ] = "use of bpf to read kernel RAM", + [LOCKDOWN_PERF] = "unsafe use of perf", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 25/29 kexec: Allow kexec_file() with appropriate IMA policy when locked down
In reply to Matthew GarrettSystems in lockdown mode should block the kexec of untrusted kernels. For x86 and ARM we can ensure that a kernel is trustworthy by validating a PE signature, but this isn't possible on other architectures. On those platforms we can use IMA digital signatures instead. Add a function to determine whether IMA has or will verify signatures for a given event type, and if so permit kexec_file() even if the kernel is otherwise locked down. This is restricted to cases where CONFIG_INTEGRITY_TRUSTED_KEYRING is set in order to prevent an attacker from loading additional keys at runtime.
--- include/linux/ima.h | 9 ++++++ kernel/kexec_file.c | 10 +++++- security/integrity/ima/ima.h | 2 ++ security/integrity/ima/ima_main.c | 2 +- security/integrity/ima/ima_policy.c | 50 +++++++++++++++++++++++++++++ 5 files changed, 71 insertions(+), 2 deletions(-)
include/linux/ima.h +9 -0
@@ -129,4 +129,13 @@ static inline int ima_inode_removexattr(struct dentry *dentry,return 0 ; }#endif /* CONFIG_IMA_APPRAISE */ + +#if defined(CONFIG_IMA_APPRAISE ) && defined(CONFIG_INTEGRITY_TRUSTED_KEYRING ) +extern bool ima_appraise_signature (enum kernel_read_file_id func); +#else +static inline bool ima_appraise_signature (enum kernel_read_file_id func) +{ +return false; +} +#endif /* CONFIG_IMA_APPRAISE && CONFIG_INTEGRITY_TRUSTED_KEYRING */ #endif /* _LINUX_IMA_H */
kernel/kexec_file.c +9 -1
@@ -208,7 +208,15 @@ kimage_validate_signature(struct kimage *image)return ret; } -return security_locked_down (LOCKDOWN_KEXEC ); +/* If IMA is guaranteed to appraise a signature on the kexec +* image, permit it even if the kernel is otherwise locked +* down. +*/ +if (!ima_appraise_signature (READING_KEXEC_IMAGE ) && +security_locked_down (LOCKDOWN_KEXEC )) +return -EPERM ; + +return 0 ;/* All other errors are fatal, including nomem, unparseable * signatures and signature check failures - even if signatures
security/integrity/ima/ima.h +2 -0
@@ -111,6 +111,8 @@ struct ima_kexec_hdr {u64 count; }; +extern const int read_idmap[]; +#ifdef CONFIG_HAVE_IMA_KEXEC void ima_load_kexec_buffer (void );#else
security/integrity/ima/ima_main.c +1 -1
@@ -469,7 +469,7 @@ int ima_read_file(struct file *file, enum kernel_read_file_id read_id)return 0 ; } -static const int read_idmap[READING_MAX_ID ] = { +const int read_idmap[READING_MAX_ID ] = { [READING_FIRMWARE ] =FIRMWARE_CHECK , [READING_FIRMWARE_PREALLOC_BUFFER ] =FIRMWARE_CHECK , [READING_MODULE ] =MODULE_CHECK ,
security/integrity/ima/ima_policy.c +50 -0
53 lines not on this page · raw message
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 26/29 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 | 30 ++++++++++++++++++++++++++++++ fs/debugfs/inode.c | 32 ++++++++++++++++++++++++++++++-- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 4 files changed, 62 insertions(+), 2 deletions(-)
fs/debugfs/file.c +30 -0
@@ -19,6 +19,7 @@#include <linux/atomic.h> #include <linux/device.h> #include <linux/poll.h> +#include <linux/security.h> #include "internal.h"
@@ -136,6 +137,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 security_locked_down (LOCKDOWN_DEBUGFS ); +} +static int open_proxy_open (struct inode *inode,struct file *filp) {struct dentry *dentry =F_DENTRY (filp);
@@ -147,6 +167,11 @@ static int open_proxy_open(struct inode *inode, struct file *filp)return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); + + r =debugfs_is_locked_down (inode, filp, real_fops); +if (r) + goto out; + real_fops =fops_get (real_fops);if (!real_fops) {/* Huh? Module did not clean up after itself at exit? */
@@ -272,6 +297,11 @@ static int full_proxy_open(struct inode *inode, struct file *filp)return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); + + r =debugfs_is_locked_down (inode, filp, real_fops); +if (r) + goto out; + real_fops =fops_get (real_fops);if (!real_fops) {/* Huh? Module did not cleanup after itself at exit? */
fs/debugfs/inode.c +30 -2
@@ -23,6 +23,7 @@#include <linux/parser.h> #include <linux/magic.h> #include <linux/slab.h> +#include <linux/security.h> #include "internal.h"
@@ -32,6 +33,32 @@ 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) +{ +int ret =security_locked_down (LOCKDOWN_DEBUGFS ); + +if (ret && (ia->ia_valid & (ATTR_MODE |ATTR_UID |ATTR_GID ))) +return ret; +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);
@@ -355,6 +382,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 );
@@ -515,7 +543,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) */
@@ -610,7 +638,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);
include/linux/security.h +1 -0
@@ -115,6 +115,7 @@ enum lockdown_reason {LOCKDOWN_TIOCSSERIAL ,LOCKDOWN_MODULE_PARAMETERS ,LOCKDOWN_MMIOTRACE , +LOCKDOWN_DEBUGFS ,LOCKDOWN_INTEGRITY_MAX ,LOCKDOWN_KCORE , LOCKDOWN_KPROBES,
security/lockdown/lockdown.c +1 -0
@@ -30,6 +30,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO", [LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters", [LOCKDOWN_MMIOTRACE] = "unsafe mmio", + [LOCKDOWN_DEBUGFS] = "debugfs access", [LOCKDOWN_INTEGRITY_MAX] = "integrity", [LOCKDOWN_KCORE] = "/proc/kcore access", [LOCKDOWN_KPROBES] = "use of kprobes",
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 27/29 tracefs: Restrict tracefs when the kernel is locked down
In reply to Matthew GarrettTracefs may release more information about the kernel than desirable, so restrict it when the kernel is locked down in confidentiality mode by preventing open().
(Fixed by Ben Hutchings to avoid a null dereference in default_file_open())
--- fs/tracefs/inode.c | 42 +++++++++++++++++++++++++++++++++++- include/linux/security.h | 1 + security/lockdown/lockdown.c | 1 + 3 files changed, 43 insertions(+), 1 deletion(-)
fs/tracefs/inode.c +41 -1
@@ -20,6 +20,7 @@#include <linux/parser.h> #include <linux/magic.h> #include <linux/slab.h> +#include <linux/security.h> #define TRACEFS_DEFAULT_MODE 0700
@@ -27,6 +28,25 @@ static struct vfsmount *tracefs_mount;static int tracefs_mount_count;static bool tracefs_registered; +static int default_open_file (struct inode *inode,struct file *filp) +{ +struct dentry *dentry = filp->f_path.dentry; +struct file_operations *real_fops; +int ret; + +if (!dentry) +return -EINVAL ; + + ret =security_locked_down (LOCKDOWN_TRACEFS ); +if (ret) +return ret; + + real_fops = dentry->d_fsdata; +if (!real_fops->open) +return 0 ; +return real_fops->open (inode, filp); +} +static ssize_t default_read_file (struct file *file,char __user *buf,size_t count,loff_t *ppos) {
@@ -221,6 +241,12 @@ static int tracefs_apply_options(struct super_block *sb)return 0 ; } +static void tracefs_destroy_inode (struct inode *inode) +{ +if (S_ISREG (inode->i_mode)) +kfree (inode->i_fop); +} +static int tracefs_remount (struct super_block *sb,int *flags,char *data) {int err;
@@ -257,6 +283,7 @@ static int tracefs_show_options(struct seq_file *m, struct dentry *root)static const struct super_operations tracefs_super_operations = { .statfs = simple_statfs, .remount_fs = tracefs_remount, + .destroy_inode = tracefs_destroy_inode, .show_options = tracefs_show_options, };
@@ -387,6 +414,7 @@ struct dentry *tracefs_create_file(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops) { + struct file_operations *proxy_fops;struct dentry *dentry;struct inode *inode;
@@ -402,8 +430,20 @@ struct dentry *tracefs_create_file(const char *name, umode_t mode,if (unlikely (!inode))return failed_creating (dentry); + proxy_fops =kzalloc (sizeof (struct file_operations ),GFP_KERNEL ); +if (unlikely (!proxy_fops)) { +iput (inode); +return failed_creating (dentry); + } + +if (!fops) + fops = &tracefs_file_operations; + + dentry->d_fsdata = (void *)fops; +memcpy (proxy_fops, fops,sizeof (*proxy_fops)); + proxy_fops->open = default_open_file; inode->i_mode = mode; - inode->i_fop = fops ? fops : &tracefs_file_operations; + inode->i_fop = proxy_fops; inode->i_private = data;d_instantiate (dentry, inode);fsnotify_create (dentry->d_parent->d_inode, dentry);
include/linux/security.h +1 -0
@@ -121,6 +121,7 @@ enum lockdown_reason {LOCKDOWN_KPROBES ,LOCKDOWN_BPF_READ ,LOCKDOWN_PERF , +LOCKDOWN_TRACEFS , LOCKDOWN_CONFIDENTIALITY_MAX, };
security/lockdown/lockdown.c +1 -0
@@ -36,6 +36,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { [LOCKDOWN_KPROBES] = "use of kprobes", [LOCKDOWN_BPF_READ] = "use of bpf to read kernel RAM", [LOCKDOWN_PERF] = "unsafe use of perf", + [LOCKDOWN_TRACEFS] = "use of tracefs", [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality", };
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 28/29 efi: Restrict efivar_ssdt_load when the kernel is locked down
In reply to Matthew Garrettefivar_ssdt_load allows the kernel to import arbitrary ACPI code from an EFI variable, which gives arbitrary code execution in ring 0. Prevent that when the kernel is locked down.
--- drivers/firmware/efi/efi.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/firmware/efi/efi.c +6 -0
@@ -30,6 +30,7 @@#include <linux/acpi.h> #include <linux/ucs2_string.h> #include <linux/memblock.h> +#include <linux/security.h> #include <asm/early_ioremap.h>
@@ -241,6 +242,11 @@ static void generic_ops_unregister(void)static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX ]__initdata ;static int __init efivar_ssdt_setup (char *str) { +int ret =security_locked_down (LOCKDOWN_ACPI_TABLES ); + +if (ret) +return ret; +if (strlen (str) <sizeof (efivar_ssdt))memcpy (efivar_ssdt, str,strlen (str));else
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
PATCH v40 29/29 lockdown: Print current->comm in restriction messages
In reply to Matthew GarrettPrint 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
--- fs/proc/kcore.c | 5 +++-- security/lockdown/lockdown.c | 8 ++++++-- 2 files changed, 9 insertions(+), 4 deletions(-)
fs/proc/kcore.c +3 -2
@@ -548,11 +548,12 @@ static int open_kcore(struct inode *inode, struct file *filp) {int ret =security_locked_down (LOCKDOWN_KCORE ); -if (ret) -return ret;if (!capable (CAP_SYS_RAWIO ))return -EPERM ; +if (ret) +return ret; + filp->private_data =kmalloc (PAGE_SIZE ,GFP_KERNEL );if (!filp->private_data)return -ENOMEM ;
security/lockdown/lockdown.c +6 -2
@@ -81,10 +81,14 @@ early_param("lockdown", lockdown_param);*/ static int lockdown_is_locked_down (enum lockdown_reason what) { +if (WARN (what >=LOCKDOWN_CONFIDENTIALITY_MAX , +"Invalid lockdown reason" )) +return -EPERM ; +if (kernel_locked_down >= what) {if (lockdown_reasons[what]) -pr_notice ("Lockdown: %s is restricted; see man kernel_lockdown.7\n" , - lockdown_reasons[what]); +pr_notice ("Lockdown: %s: %s is restricted; see man kernel_lockdown.7\n" , + current->comm, lockdown_reasons[what]);return -EPERM ; }
Signature · 1 line
2.23.0.rc1.153.gdeed80330f-goog
James Morris
maintainerQuoted 4 lines · Matthew Garrett
After chatting with James in person, I'm resending the full set with the fixes merged in in order to avoid any bisect issues. There should be no functional changes other than avoiding build failures with some configs, and fixing the oops in tracefs.
Applied togit://git.kernel.org/pub/scm/linux/kernel/git/jmorris/linux-security.git next-lockdown and next-testing
Thanks!
Signature · 2 lines
James Morris <[email protected]>