Lockdown patches for 5.2
Subsystems (34)
v32 cover Lockdown patches for 5.2
Fairly minimal changes since the last set: tracefs is restricted at Steven's suggestion (but could do with a once-over, I'm very much not a vfs person), debugfs is back to Dave's original implementation. I've also fixed up a malformed patch that resulted from me getting confused during rebase, and added some further documentation to the initial patch in order to give a reference for the design goals.
PATCH v32 1/27 Add the ability to lock down access to the running kernel image
From: David Howells <[email protected]>
Provide a single call to allow kernel code to determine whether the system should be locked down, thereby disallowing various accesses that might allow the running kernel image to be changed including the loading of modules that aren't validly signed with a key we recognise, fiddling with MSR registers and disallowing hibernation.
--- Documentation/ABI/testing/lockdown | 19 +++ .../admin-guide/kernel-parameters.txt | 9 ++ Documentation/admin-guide/lockdown.rst | 60 +++++++ include/linux/kernel.h | 28 ++++ include/linux/security.h | 9 +- init/main.c | 1 + security/Kconfig | 39 +++++ security/Makefile | 3 + security/lock_down.c | 147 ++++++++++++++++++ 9 files changed, 314 insertions(+), 1 deletion(-) create mode 100644 Documentation/ABI/testing/lockdown create mode 100644 Documentation/admin-guide/lockdown.rst create mode 100644 security/lock_down.c
Documentation/ABI/testing/lockdown new file +19 -0
@@ -0,0 +1,19 @@ +What: security/lockdown +Date: March 2019 +Contact: Matthew Garrett <[email protected]> +Description: + If CONFIG_LOCK_DOWN_KERNEL is enabled, the kernel can be + moved to a more locked down state at runtime by writing to + this attribute. Valid values are: + + integrity: + The kernel will disable functionality that allows + userland to modify the running kernel image, other + than through the loading or execution of appropriately + signed objects. + + confidentiality: + The kernel will disable all functionality disabled by + the integrity mode, but additionally will disable + features that potentially permit userland to obtain + confidential information stored within the kernel.
Documentation/admin-guide/kernel-parameters.txt +9 -0
@@ -2213,6 +2213,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
Documentation/admin-guide/lockdown.rst new file +60 -0
60 lines not on this page · raw message
include/linux/kernel.h +28 -0
@@ -340,6 +340,34 @@ static inline void refcount_error_report(struct pt_regs *regs, const char *err) { }#endif +enum lockdown_level { +LOCKDOWN_NONE , +LOCKDOWN_INTEGRITY , +LOCKDOWN_CONFIDENTIALITY , +LOCKDOWN_MAX , +}; + +#ifdef CONFIG_LOCK_DOWN_KERNEL +extern bool __kernel_is_locked_down (const char *what, +enum lockdown_level level, +bool first); +#else +static inline bool __kernel_is_locked_down (const char *what, +enum lockdown_level level, +bool first) +{ +return false; +} +#endif + +#define kernel_is_locked_down (what, level) \ + ({ \ + static bool message_given; \ + bool locked_down = __kernel_is_locked_down(what, level, !message_given); \ + message_given = true; \ + locked_down; \ + }) +/* Internal, do not use. */ int __must_check _kstrtoul (const char *s,unsigned int base,unsigned long *res);int __must_check _kstrtol (const char *s,unsigned int base,long *res);
include/linux/security.h +8 -1
@@ -1798,5 +1798,12 @@ static inline void security_bpf_prog_free(struct bpf_prog_aux *aux)#endif /* CONFIG_SECURITY */ #endif /* CONFIG_BPF_SYSCALL */ -#endif /* ! __LINUX_SECURITY_H */ +#ifdef CONFIG_LOCK_DOWN_KERNEL +extern void __init init_lockdown (void ); +#else +static inline void __init init_lockdown (void ) +{ +} +#endif +#endif /* ! __LINUX_SECURITY_H */
init/main.c +1 -0
@@ -555,6 +555,7 @@ asmlinkage __visible void __init start_kernel(void)boot_cpu_init ();page_address_init ();pr_notice ("%s" , linux_banner); +init_lockdown ();setup_arch (&command_line);/* * Set up the the initial canary and entropy after arch
security/Kconfig +39 -0
@@ -229,6 +229,45 @@ config STATIC_USERMODEHELPER_PATH If you wish for all usermode helper programs to be disabled, specify an empty string here (i.e. ""). +config LOCK_DOWN_KERNEL + bool "Allow the kernel to be 'locked down'" + help + Allow the kernel to be locked down. If lockdown support is enabled + and activated, the kernel will impose additional restrictions + intended to prevent uid 0 from being able to modify the running + kernel. This may break userland applications that rely on low-level + access to hardware. + +choice + prompt "Kernel default lockdown mode" + default LOCK_DOWN_KERNEL_FORCE_NONE + depends on LOCK_DOWN_KERNEL + help + The kernel can be configured to default to differing levels of + lockdown. + +config LOCK_DOWN_KERNEL_FORCE_NONE + bool "None" + help + No lockdown functionality is enabled by default. Lockdown may be + enabled via the kernel commandline or /sys/kernel/security/lockdown. + +config LOCK_DOWN_KERNEL_FORCE_INTEGRITY + bool "Integrity" + help + The kernel runs in integrity mode by default. Features that allow + the kernel to be modified at runtime are disabled. + +config LOCK_DOWN_KERNEL_FORCE_CONFIDENTIALITY + bool "Confidentiality" + help + The kernel runs in confidentiality mode by default. Features that + allow the kernel to be modified at runtime or that permit userland + code to read confidential material held inside the kernel are + disabled. + +endchoice + source "security/selinux/Kconfig" source "security/smack/Kconfig" source "security/tomoyo/Kconfig"
security/Makefile +3 -0
@@ -32,3 +32,6 @@ obj-$(CONFIG_CGROUP_DEVICE) += device_cgroup.o # Object integrity file lists subdir-$(CONFIG_INTEGRITY) += integrity obj-$(CONFIG_INTEGRITY) += integrity/ + +# Allow the kernel to be locked down +obj-$(CONFIG_LOCK_DOWN_KERNEL) += lock_down.o
security/lock_down.c new file +147 -0
147 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 15 lines · Matthew Garrett
Documentation/ABI/testing/lockdown new file +9
-0@@ -0,0 +1,19 @@ +What: security/lockdown +Date: March 2019 +Contact: Matthew Garrett <[email protected]> +Description: + If CONFIG_LOCK_DOWN_KERNEL is enabled, the kernel can be + moved to a more locked down state at runtime by writing to + this attribute. Valid values are: + + integrity:
Documentation/ABI/testing/lockdown line 19
Quoted 10 lines
Documentation/ABI/testing/lockdown new file +10
-0+ The kernel will disable functionality that allows + userland to modify the running kernel image, other + than through the loading or execution of appropriately + signed objects. + + confidentiality: + The kernel will disable all functionality disabled by + the integrity mode, but additionally will disable + features that potentially permit userland to obtain + confidential information stored within the kernel.
[+ linuxppc, mpe, dja, cmr]
I'm thinking about whether we should lock down the powerpc xmon debug monitor - intuitively, I think the answer is yes if for no other reason than Least Astonishment, when lockdown is enabled you probably don't expect xmon to keep letting you access kernel memory.
Semantically though, xmon is not a userspace process - it's in kernel and reads debug commands/outputs debug data directly from/to the console. Is that a threat vector that this series cares about?
Signature · 2 lines
Andrew Donnellan OzLabs, ADL Canberra [email protected] IBM Australia Limited
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Hi Andrew,
Quoted 18 lines
Quoted 5 lines
Documentation/ABI/testing/lockdown new file +5
-0+ If CONFIG_LOCK_DOWN_KERNEL is enabled, the kernel can be + moved to a more locked down state at runtime by writing to + this attribute. Valid values are: + + integrity:Documentation/ABI/testing/lockdown line 19
Quoted 10 lines
Documentation/ABI/testing/lockdown new file +10
-0+ The kernel will disable functionality that allows + userland to modify the running kernel image, other + than through the loading or execution of appropriately + signed objects. + + confidentiality: + The kernel will disable all functionality disabled by + the integrity mode, but additionally will disable + features that potentially permit userland to obtain + confidential information stored within the kernel.[+ linuxppc, mpe, dja, cmr]
Quoted 8 lines
I'm thinking about whether we should lock down the powerpc xmon debug monitor - intuitively, I think the answer is yes if for no other reason than Least Astonishment, when lockdown is enabled you probably don't expect xmon to keep letting you access kernel memory.
Semantically though, xmon is not a userspace process - it's in kernel and reads debug commands/outputs debug data directly from/to the console. Is that a threat vector that this series cares about?
I guess there are 2 ways you could think about lockdown:
- It adds a security boundary between the kernel and UID 0, so that userland cannot compromise the integrity/confidentiality of the locked down kernel.
- It is a bundle of related security boundaries so that the integrity/confidentiality of a running, locked down kernel cannot be compromised, even by a privileged, physically present user.
You're right that techincally xmon is in the kernel and on the console rather than in userland, so it doesn't fall within the first concept of lockdown. But I think usecases for lockdown tend to expect something more like the second concept.
IOW, lockdown is a trapdoor - once you've locked down a kernel, you can't get out of lockdown (except by rebooting). xmon would allow you to get out of the trapdoor, so I think it should be restricted by lockdown.
Regards,
Daniel
Quoted 5 lines
Signature · 3 lines
-- Andrew Donnellan OzLabs, ADL Canberra [email protected] IBM Australia Limited
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
In reply to Andrew DonnellanQuoted 4 lines · Andrew Donnellan
I'm thinking about whether we should lock down the powerpc xmon debug monitor - intuitively, I think the answer is yes if for no other reason than Least Astonishment, when lockdown is enabled you probably don't expect xmon to keep letting you access kernel memory.
The original patchset contained a sysrq hotkey to allow physically present users to disable lockdown, so I'm not super concerned about this case - I could definitely be convinced otherwise, though.
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 10 lines · Matthew Garrett
Quoted 4 lines · Andrew Donnellan
I'm thinking about whether we should lock down the powerpc xmon debug monitor - intuitively, I think the answer is yes if for no other reason than Least Astonishment, when lockdown is enabled you probably don't expect xmon to keep letting you access kernel memory.
The original patchset contained a sysrq hotkey to allow physically present users to disable lockdown, so I'm not super concerned about this case - I could definitely be convinced otherwise, though.
So currently (and I'm pretty new to this as I've only recently rejoined IBM) we aren't considering access to the console to be sufficient to assert physical presence on bare-metal server-class Power machines. The short argument for this is that with IPMI and BMCs, a server's console isn't what it used to be. Our console is also a bit different to x86:
we don't generally have bios configuration screens on the console.
In your example, a sysrq key would allow you to disable lockdown after the system has booted. On Power though, we use Linux as a bootloader (Petitboot: https://github.com/open-power/petitboot) so being able to disable lockdown there allows an IPMI-connected user to prevent a signed kernel being loaded in the first place. I don't know if this is _actually_ worse, but it certainly feels worse.
There are of course some arguments against our approach. I'm aware of some of them. I'm also very open to being told that not equating console access with physical access is fundamentally silly or broken and that we should rethink things.
Regards,
Daniel
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Hi,
Quoted 8 lines
Quoted 8 lines
Quoted 4 lines
I'm thinking about whether we should lock down the powerpc xmon debug monitor - intuitively, I think the answer is yes if for no other reason than Least Astonishment, when lockdown is enabled you probably don't expect xmon to keep letting you access kernel memory.
The original patchset contained a sysrq hotkey to allow physically present users to disable lockdown, so I'm not super concerned about this case - I could definitely be convinced otherwise, though.
So Mimi contacted me offlist and very helpfully provided me with a much better and less confused justification for disabling xmon in lockdown:
On x86, physical presence (== console access) is a trigger to disable/enable lockdown mode.
In lockdown mode, you're not supposed to be able to modify memory. xmon allows you to modify memory, and therefore shouldn't be allowed in lockdown.
So, if you can disable lockdown on the console that's probably OK, but it should be specifically disabling lockdown, not randomly editing memory with xmon.
Regards,
Daniel
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 17 lines · Daniel Axtens
Hi,
Quoted 8 lines
Quoted 8 lines
Quoted 4 lines
I'm thinking about whether we should lock down the powerpc xmon debug monitor - intuitively, I think the answer is yes if for no other reason than Least Astonishment, when lockdown is enabled you probably don't expect xmon to keep letting you access kernel memory.
The original patchset contained a sysrq hotkey to allow physically present users to disable lockdown, so I'm not super concerned about this case - I could definitely be convinced otherwise, though.
So Mimi contacted me offlist and very helpfully provided me with a much better and less confused justification for disabling xmon in lockdown:
On x86, physical presence (== console access) is a trigger to disable/enable lockdown mode.
Quoted 7 lines
In lockdown mode, you're not supposed to be able to modify memory. xmon allows you to modify memory, and therefore shouldn't be allowed in lockdown.
So, if you can disable lockdown on the console that's probably OK, but it should be specifically disabling lockdown, not randomly editing memory with xmon.
That makes sense.
Signature · 2 lines
Andrew Donnellan OzLabs, ADL Canberra [email protected] IBM Australia Limited
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
In reply to Matthew GarrettHi James,
What's the best way forward with this? I'm still not entirely clear on how it can be implemented purely as an LSM, but if you have ideas on what sort of implementation you'd prefer I'm happy to work on that.
James Morris
maintainerRe: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 5 lines · Matthew Garrett
Hi James,
What's the best way forward with this? I'm still not entirely clear on how it can be implemented purely as an LSM, but if you have ideas on what sort of implementation you'd prefer I'm happy to work on that.
It can't be implemented purely as an LSM.
The concerns I have are:
o Mixing of mechanism and policy (they are hardcoded together)
o Too-coarse policy (all or nothing, which will lead many to choose nothing)
o Lack of integration with LSM
o Completeness
o Maintenance (including adding new lockdowns without breaking existing userspace)
One possible direction is to (as previously mentioned) assign IDs to each callsite and be able to check this ID against a simple policy array (allow/deny). The default policy choices could be reduced to 'all' or 'none' during kconfig, and allow a custom policy to be loaded later if desired.
Within the policy check hook, we could add a new LSM hook, which would allow an LSM to restrictively override the lockdown policy with its own (so e.g. SELinux could utilize the context of the current process to determine if a lockdown feature should be enforced).
This doesn't really address the completeness / maintenance issue (i.e. "do we have everything covered and how do we ensure this on an ongoing basis?", and "what will this new lockdown feature break?"), although it should make it easier to add new lockdown callsites as they don't have to be enabled by the user.
Thoughts?
Signature · 2 lines
James Morris <[email protected]>
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 5 lines · James Morris
One possible direction is to (as previously mentioned) assign IDs to each callsite and be able to check this ID against a simple policy array (allow/deny). The default policy choices could be reduced to 'all' or 'none' during kconfig, and allow a custom policy to be loaded later if desired.
Ok. My primary concern around this is that it's very difficult to use correctly in anything other than the "all" or "none" modes. If a new kernel feature is added with integrated lockdown support, if an admin is simply setting the flags of things they wish to block then this will be left enabled - and may violate the admin's expectations around integrity. On the other hand, if an admin is simply setting the flags of things they wish to permit, then adding lockdown support to an existing kernel feature may result in that feature suddenly being disabled, which may also violate the admin's expectations around the flags providing a stable set of behaviour.
Given that, would you prefer such a policy expression to look like?
Quoted 2 lines
Within the policy check hook, we could add a new LSM hook, which would allow an LSM to restrictively override the lockdown policy with its own
Ok, that makes sense. If we take this approach, does there need to be a separate policy mechanism at all? Users who want fine-grained control would be able to set the behaviour to "None" and then use their choice of LSM to express more fine-grained control.
Quoted 5 lines
This doesn't really address the completeness / maintenance issue (i.e. "do we have everything covered and how do we ensure this on an ongoing basis?", and "what will this new lockdown feature break?"), although it should make it easier to add new lockdown callsites as they don't have to be enabled by the user.
I can start on this.
James Morris
maintainerRe: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 7 lines · Matthew Garrett
Quoted 5 lines · James Morris
One possible direction is to (as previously mentioned) assign IDs to each callsite and be able to check this ID against a simple policy array (allow/deny). The default policy choices could be reduced to 'all' or 'none' during kconfig, and allow a custom policy to be loaded later if desired.
Quoted 10 lines
Ok. My primary concern around this is that it's very difficult to use correctly in anything other than the "all" or "none" modes. If a new kernel feature is added with integrated lockdown support, if an admin is simply setting the flags of things they wish to block then this will be left enabled - and may violate the admin's expectations around integrity. On the other hand, if an admin is simply setting the flags of things they wish to permit, then adding lockdown support to an existing kernel feature may result in that feature suddenly being disabled, which may also violate the admin's expectations around the flags providing a stable set of behaviour.
Understood. Most uses will likely be either a distro or an embedded system, who I'm assuming would provide a useful policy by default, and perhaps a high-level abstraction for modification.
Quoted 1 line
Given that, would you prefer such a policy expression to look like?
Perhaps a write-once policy, injected from userspace during early boot?
The policy could be simply a list of:
lockdown_feature true|false
Quoted 8 lines
Quoted 3 lines
Within the policy check hook, we could add a new LSM hook, which would allow an LSM to restrictively override the lockdown policy with its own
Ok, that makes sense. If we take this approach, does there need to be a separate policy mechanism at all? Users who want fine-grained control would be able to set the behaviour to "None" and then use their choice of LSM to express more fine-grained control.
Right, and there could be a stackable LSM which just does fine-grained policy (per above).
Quoted 8 lines
Quoted 6 lines
This doesn't really address the completeness / maintenance issue (i.e. "do we have everything covered and how do we ensure this on an ongoing basis?", and "what will this new lockdown feature break?"), although it should make it easier to add new lockdown callsites as they don't have to be enabled by the user.
I can start on this.
Cool!
Signature · 2 lines
James Morris <[email protected]>
Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image
Quoted 27 lines · James Morris
Quoted 10 lines · Matthew Garrett
Quoted 7 lines · James Morris
One possible direction is to (as previously mentioned) assign IDs to each callsite and be able to check this ID against a simple policy array (allow/deny). The default policy choices could be reduced to 'all' or 'none' during kconfig, and allow a custom policy to be loaded later if desired.
Quoted 10 lines
Ok. My primary concern around this is that it's very difficult to use correctly in anything other than the "all" or "none" modes. If a new kernel feature is added with integrated lockdown support, if an admin is simply setting the flags of things they wish to block then this will be left enabled - and may violate the admin's expectations around integrity. On the other hand, if an admin is simply setting the flags of things they wish to permit, then adding lockdown support to an existing kernel feature may result in that feature suddenly being disabled, which may also violate the admin's expectations around the flags providing a stable set of behaviour.
Understood. Most uses will likely be either a distro or an embedded system, who I'm assuming would provide a useful policy by default, and perhaps a high-level abstraction for modification.
Quoted 8 lines
Quoted 1 line
Given that, would you prefer such a policy expression to look like?
Perhaps a write-once policy, injected from userspace during early boot?
The policy could be simply a list of:
lockdown_featuretrue|false
I’m not convinced this is worthwhile. As I see it, there really are only two privileges here: root can read kernel memory, and root can corrupt kernel state. A policy that root can’t corrupt kernel memory except using, say, eBPF is useless — it gives warm fuzzy feelings but nothing else.
PATCH v32 2/27 Enforce module signatures if the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
If the kernel is locked down, require that all modules have valid signatures that we can verify.
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.]
--- kernel/module.c | 39 ++++++++++++++++++++++++++++++++------- 1 file changed, 32 insertions(+), 7 deletions(-)
kernel/module.c +32 -7
@@ -2767,8 +2767,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;/*
@@ -2783,16 +2784,40 @@ static int module_sig_check(struct load_info *info, int flags) err = mod_verify_sig(mod, info); } -if (!err) { +switch (err) { +case 0 : info->sig_ok = true;return 0 ; - } -/* Not having a signature is only an error if we're strict. */ -if (err == -ENOKEY && !is_module_sig_enforced ()) - err =0 ; +/* We don't permit modules to be loaded into trusted kernels +* without a valid signature on them, but if we're not +* enforcing, certain errors are non-fatal. +*/ +case -ENODATA : + reason ="Loading of unsigned module" ; + goto decide; +case -ENOPKG : + reason ="Loading of module with unsupported crypto" ; + goto decide; +case -ENOKEY : + reason ="Loading of module with unavailable key" ; + decide: +if (is_module_sig_enforced ()) { +pr_notice ("%s is rejected\n" , reason); +return -EKEYREJECTED ; + } -return err; +if (kernel_is_locked_down (reason,LOCKDOWN_INTEGRITY )) +return -EPERM ; +return 0 ; + +/* All other errors are fatal, including nomem, unparseable +* signatures and signature check failures - even if signatures +* aren't required. +*/ +default : +return err; + } }#else /* !CONFIG_MODULE_SIG */ static int module_sig_check (struct load_info *info,int flags)
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 3/27 Restrict /dev/{mem,kmem,port} when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
Allowing users to read and write to core kernel memory makes it possible for the kernel to be subverted, avoiding module loading restrictions, and also to steal cryptographic information.
Disallow /dev/mem and /dev/kmem from being opened this when the kernel has been locked down to prevent this.
Also disallow /dev/port from being opened to prevent raw ioport access and thus DMA from being used to accomplish the same thing.
--- drivers/char/mem.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/char/mem.c +2 -0
@@ -786,6 +786,8 @@ static loff_t memory_lseek(struct file *file, loff_t offset, int orig)static int open_port (struct inode *inode,struct file *filp) { +if (kernel_is_locked_down ("/dev/mem,kmem,port" ,LOCKDOWN_INTEGRITY )) +return -EPERM ;return capable (CAP_SYS_RAWIO ) ?0 : -EPERM ; }
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 4/27 kexec_load: Disable at runtime if the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
The kexec_load() syscall permits the loading and execution of arbitrary code in ring 0, which is something that lock-down is meant to prevent. It makes sense to disable kexec_load() in this situation.
This does not affect kexec_file_load() syscall which can check for a signature on the image to be booted.
--- kernel/kexec.c | 8 ++++++++ 1 file changed, 8 insertions(+)
kernel/kexec.c +8 -0
@@ -207,6 +207,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 +*/ +if (kernel_is_locked_down ("kexec of unsigned images" , +LOCKDOWN_INTEGRITY )) +return -EPERM ; +/* * Verify we have a legal set of flags * This leaves us room for future extensions.
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 5/27 Copy secure_boot flag in boot params across kexec reboot
In reply to Matthew GarrettFrom: Dave Young <[email protected]>
Kexec reboot in case secure boot being enabled does not keep the secure boot mode in new kernel, so later one can load unsigned kernel via legacy kexec_load. In this state, the system is missing the protections provided by secure boot.
Adding a patch to fix this by retain the secure_boot flag in original kernel.
secure_boot flag in boot_params is set in EFI stub, but kexec bypasses the stub. Fixing this issue by copying secure_boot flag across kexec reboot.
--- arch/x86/kernel/kexec-bzimage64.c | 1 + 1 file changed, 1 insertion(+)
arch/x86/kernel/kexec-bzimage64.c +1 -0
@@ -179,6 +179,7 @@ setup_efi_state(struct boot_params *params, unsigned long params_load_addr,if (efi_enabled (EFI_OLD_MEMMAP ))return 0 ; + params->secure_boot = boot_params.secure_boot; ei->efi_loader_signature = current_ei->efi_loader_signature; ei->efi_systab = current_ei->efi_systab; ei->efi_systab_hi = current_ei->efi_systab_hi;
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 6/27 kexec_file: split KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE
In reply to Matthew GarrettFrom: Jiri Bohac <[email protected]>
This is a preparatory patch for kexec_file_load() lockdown. A locked down kernel needs to prevent unsigned kernel images from being loaded with kexec_file_load(). Currently, the only way to force the signature verification is compiling with KEXEC_VERIFY_SIG. This prevents loading usigned images even when the kernel is not locked down at runtime.
This patch splits KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE. Analogous to the MODULE_SIG and MODULE_SIG_FORCE for modules, KEXEC_SIG turns on the signature verification but allows unsigned images to be loaded. KEXEC_SIG_FORCE disallows images without a valid signature.
[Modified by David Howells such that:
(1) verify_pefile_signature() differentiates between no-signature and sig-didn't-match in its returned errors.
(2) kexec fails with EKEYREJECTED and logs an appropriate message if signature checking is enforced and an signature is not found, uses unsupported crypto or has no matching key.
(3) kexec fails with EKEYREJECTED if there is a signature for which we have a key, but signature doesn't match - even if in non-forcing mode.
(4) kexec fails with EBADMSG or some other error if there is a signature which cannot be parsed - even if in non-forcing mode.
(5) kexec fails with ELIBBAD if the PE file cannot be parsed to extract the signature - even if in non-forcing mode.
]
--- arch/x86/Kconfig | 20 ++++++++--- crypto/asymmetric_keys/verify_pefile.c | 4 ++- include/linux/kexec.h | 4 +-- kernel/kexec_file.c | 48 ++++++++++++++++++++++---- 4 files changed, 61 insertions(+), 15 deletions(-)
arch/x86/Kconfig +15 -5
@@ -2016,20 +2016,30 @@ config KEXEC_FILE config ARCH_HAS_KEXEC_PURGATORY def_bool KEXEC_FILE -config KEXEC_VERIFY_SIG +config KEXEC_SIG bool "Verify kernel signature during kexec_file_load() syscall" depends on KEXEC_FILE ---help--- - This option makes kernel signature verification mandatory for - the kexec_file_load() syscall. - In addition to that option, you need to enable signature + This option makes the kexec_file_load() syscall check for a valid + signature of the kernel image. The image can still be loaded without + a valid signature unless you also enable KEXEC_SIG_FORCE, though if + there's a signature that we can check, then it must be valid. + + In addition to this option, you need to enable signature verification for the corresponding kernel image type being loaded in order for this to work. +config KEXEC_SIG_FORCE + bool "Require a valid signature in kexec_file_load() syscall" + depends on KEXEC_SIG + ---help--- + This option makes kernel signature verification mandatory for + the kexec_file_load() syscall. + config KEXEC_BZIMAGE_VERIFY_SIG bool "Enable bzImage signature verification support" - depends on KEXEC_VERIFY_SIG + depends on KEXEC_SIG depends on SIGNED_PE_FILE_VERIFICATION select SYSTEM_TRUSTED_KEYRING ---help---
crypto/asymmetric_keys/verify_pefile.c +3 -1
@@ -100,7 +100,7 @@ static int pefile_parse_binary(const void *pebuf, unsigned int pelen,if (!ddir->certs.virtual_address || !ddir->certs.size) {pr_debug ("Unsigned PE binary\n" ); -return -EKEYREJECTED ; +return -ENODATA ; } chkaddr(ctx->header_size, ddir->certs.virtual_address,
@@ -408,6 +408,8 @@ static int pefile_digest_pe(const void *pebuf, unsigned int pelen,* (*) 0 if at least one signature chain intersects with the keys in the trust * keyring, or: * +* (*) -ENODATA if there is no signature present. +* * (*) -ENOPKG if a suitable crypto module couldn't be found for a check on a * chain. *
include/linux/kexec.h +2 -2
@@ -125,7 +125,7 @@ typedef void *(kexec_load_t)(struct kimage *image, char *kernel_buf, unsigned long cmdline_len);typedef int (kexec_cleanup_t )(void *loader_data); -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC_SIG typedef int (kexec_verify_sig_t )(const char *kernel_buf,unsigned long kernel_len);#endif
@@ -134,7 +134,7 @@ struct kexec_file_ops {kexec_probe_t *probe;kexec_load_t *load;kexec_cleanup_t *cleanup; -#ifdef CONFIG_KEXEC_VERIFY_SIG +#ifdef CONFIG_KEXEC_SIG kexec_verify_sig_t *verify_sig;#endif };
kernel/kexec_file.c +41 -7
70 lines not on this page · raw message
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 7/27 kexec_file: Restrict at runtime if the kernel is locked down
In reply to Matthew GarrettFrom: Jiri Bohac <[email protected]>
When KEXEC_SIG is not enabled, kernel should not load images through kexec_file systemcall if the kernel is locked down.
[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 | 6 ++++++ 1 file changed, 6 insertions(+)
kernel/kexec_file.c +6 -0
@@ -239,6 +239,12 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd, } ret =0 ; + +if (kernel_is_locked_down (reason,LOCKDOWN_INTEGRITY )) { + ret = -EPERM ; + goto out; + } +break ;/* All other errors are fatal, including nomem, unparseable
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 8/27 hibernate: Disable when the kernel is locked down
In reply to Matthew GarrettFrom: Josh Boyer <[email protected]>
There is currently no way to verify the resume image when returning from hibernate. This might compromise the signed modules trust model, so until we can work with signed hibernate images we disable it when the kernel is locked down.
--- kernel/power/hibernate.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/power/hibernate.c +2 -1
@@ -70,7 +70,8 @@ static const struct platform_hibernation_ops *hibernation_ops;bool hibernation_available (void ) { -return (nohibernate ==0 ); +return nohibernate ==0 && !kernel_is_locked_down ("Hibernation" , +LOCKDOWN_INTEGRITY ); }/**
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 9/27 uswsusp: Disable when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
uswsusp allows a user process to dump and then restore kernel state, which makes it possible to modify the running kernel. Disable this if the kernel is locked down.
--- kernel/power/user.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/power/user.c +3 -0
@@ -52,6 +52,9 @@ static int snapshot_open(struct inode *inode, struct file *filp)if (!hibernation_available ())return -EPERM ; +if (kernel_is_locked_down ("/dev/snapshot" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +lock_system_sleep ();if (!atomic_add_unless (&snapshot_device_available,-1 ,0 )) {
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 10/27 PCI: Lock down BAR access when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
Any hardware that can potentially generate DMA has to be locked down in order to avoid it being possible for an attacker to modify kernel code, allowing them to circumvent disabled module loading or module signing. Default to paranoid - in future we can potentially relax this for sufficiently IOMMU-isolated devices.
--- drivers/pci/pci-sysfs.c | 9 +++++++++ drivers/pci/proc.c | 9 ++++++++- drivers/pci/syscall.c | 3 ++- 3 files changed, 19 insertions(+), 2 deletions(-)
drivers/pci/pci-sysfs.c +9 -0
@@ -905,6 +905,9 @@ static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,loff_t init_off = off;u8 *data = (u8 *) buf; +if (kernel_is_locked_down ("Direct PCI access" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (off > dev->cfg_size)return 0 ;if (off + count > dev->cfg_size) {
@@ -1167,6 +1170,9 @@ static int pci_mmap_resource(struct kobject *kobj, struct bin_attribute *attr,enum pci_mmap_state mmap_type;struct resource *res = &pdev->resource[bar]; +if (kernel_is_locked_down ("Direct PCI access" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (res->flags &IORESOURCE_MEM &&iomem_is_exclusive (res->start))return -EINVAL ;
@@ -1242,6 +1248,9 @@ static ssize_t pci_write_resource_io(struct file *filp, struct kobject *kobj, struct bin_attribute *attr, char *buf, loff_t off, size_t count) { + if (kernel_is_locked_down("Direct PCI access", LOCKDOWN_INTEGRITY)) + return -EPERM; +return pci_resource_io (filp, kobj, attr, buf, off, count, true); }
drivers/pci/proc.c +8 -1
@@ -117,6 +117,9 @@ static ssize_t proc_bus_pci_write(struct file *file, const char __user *buf,int size = dev->cfg_size;int cnt; +if (kernel_is_locked_down ("Direct PCI access" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (pos >= size)return 0 ;if (nbytes >= size)
@@ -196,6 +199,9 @@ static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,#endif /* HAVE_PCI_MMAP */ int ret =0 ; +if (kernel_is_locked_down ("Direct PCI access" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +switch (cmd) {case PCIIOC_CONTROLLER : ret =pci_domain_nr (dev->bus);
@@ -237,7 +243,8 @@ static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)struct pci_filp_private *fpriv = file->private_data;int i, ret, write_combine =0 , res_bit =IORESOURCE_MEM ; -if (!capable (CAP_SYS_RAWIO )) +if (!capable (CAP_SYS_RAWIO ) || +kernel_is_locked_down ("Direct PCI access" ,LOCKDOWN_INTEGRITY ))return -EPERM ;if (fpriv->mmap_state == pci_mmap_io) {
drivers/pci/syscall.c +2 -1
@@ -90,7 +90,8 @@ SYSCALL_DEFINE5(pciconfig_write, unsigned long, bus, unsigned long, dfn,u32 dword;int err =0 ; -if (!capable (CAP_SYS_ADMIN )) +if (!capable (CAP_SYS_ADMIN ) || +kernel_is_locked_down ("Direct PCI access" ,LOCKDOWN_INTEGRITY ))return -EPERM ; dev =pci_get_domain_bus_and_slot (0 , bus, dfn);
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 11/27 x86: Lock down IO port access when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
IO port access would permit users to gain access to PCI configuration registers, which in turn (on a lot of hardware) give access to MMIO register space. This would potentially permit root to trigger arbitrary DMA, so lock it down by default.
This also implicitly locks down the KDADDIO, KDDELIO, KDENABIO and KDDISABIO console ioctls.
--- arch/x86/kernel/ioport.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
arch/x86/kernel/ioport.c +4 -2
@@ -31,7 +31,8 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)if ((from + num <= from) || (from + num >IO_BITMAP_BITS ))return -EINVAL ; -if (turn_on && !capable (CAP_SYS_RAWIO )) +if (turn_on && (!capable (CAP_SYS_RAWIO ) || +kernel_is_locked_down ("ioperm" ,LOCKDOWN_INTEGRITY )))return -EPERM ;/*
@@ -126,7 +127,8 @@ SYSCALL_DEFINE1(iopl, unsigned int, level)return -EINVAL ;/* Trying to gain more privileges? */ if (level > old) { -if (!capable (CAP_SYS_RAWIO )) +if (!capable (CAP_SYS_RAWIO ) || +kernel_is_locked_down ("iopl" ,LOCKDOWN_INTEGRITY ))return -EPERM ; } regs->flags = (regs->flags & ~X86_EFLAGS_IOPL) |
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
Re: [PATCH V32 11/27] x86: Lock down IO port access when the kernel is locked down
Quoted 7 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 5 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]>
PATCH v32 12/27 x86/msr: Restrict MSR access when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
Writing to MSRs should not be allowed if the kernel is locked down, since it could lead to execution of arbitrary code in kernel mode. Based on a patch by Kees Cook.
--- arch/x86/kernel/msr.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/x86/kernel/msr.c +8 -0
@@ -84,6 +84,9 @@ static ssize_t msr_write(struct file *file, const char __user *buf,int err =0 ;ssize_t bytes =0 ; +if (kernel_is_locked_down ("Direct MSR access" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (count %8 )return -EINVAL ;/* Invalid chunk size */
@@ -135,6 +138,11 @@ static long msr_ioctl(struct file *file, unsigned int ioc, unsigned long arg) err = -EFAULT ;break ; } +if (kernel_is_locked_down ("Direct MSR access" , +LOCKDOWN_INTEGRITY )) { + err = -EPERM ; +break ; + } err =wrmsr_safe_regs_on_cpu (cpu, regs);if (err)break ;
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 13/27 ACPI: Limit access to custom_method when the kernel is locked down
In reply to Matthew GarrettFrom: Matthew Garrett <[email protected]>
custom_method effectively allows arbitrary access to system memory, making it possible for an attacker to circumvent restrictions on module loading. Disable it if the kernel is locked down.
--- drivers/acpi/custom_method.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/acpi/custom_method.c +3 -0
@@ -29,6 +29,9 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,struct acpi_table_header table;acpi_status status; +if (kernel_is_locked_down ("ACPI custom methods" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (!(*ppos)) {/* parse the table header to get the table length */ if (count <=sizeof (struct acpi_table_header ))
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 14/27 acpi: Ignore acpi_rsdp kernel param when the kernel has been locked down
In reply to Matthew GarrettFrom: Josh Boyer <[email protected]>
This option allows userspace to pass the RSDP address to the kernel, which makes it possible for a user to modify the workings of hardware . Reject the option when the kernel is locked down.
--- drivers/acpi/osl.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/acpi/osl.c +2 -1
@@ -194,7 +194,8 @@ acpi_physical_address __init acpi_os_get_root_pointer(void)acpi_physical_address pa;#ifdef CONFIG_KEXEC -if (acpi_rsdp) +if (acpi_rsdp && !kernel_is_locked_down ("ACPI RSDP specification" , +LOCKDOWN_INTEGRITY ))return acpi_rsdp;#endif pa =acpi_arch_get_root_pointer ();
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 15/27 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 | 5 +++++ 1 file changed, 5 insertions(+)
drivers/acpi/tables.c +5 -0
@@ -531,6 +531,11 @@ void __init acpi_table_upgrade(void)if (table_nr ==0 )return ; +if (kernel_is_locked_down ("ACPI table override" ,LOCKDOWN_INTEGRITY )) { +pr_notice ("kernel is locked down, ignoring table override\n" ); +return ; + } + acpi_tables_addr =memblock_find_in_range (0 ,ACPI_TABLE_UPGRADE_MAX_PHYS , all_tables_size,PAGE_SIZE );
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 16/27 Prohibit PCMCIA CIS storage when the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Prohibit replacement of the PCMCIA Card Information Structure when the kernel is locked down.
--- drivers/pcmcia/cistpl.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/pcmcia/cistpl.c +4 -0
@@ -1578,6 +1578,10 @@ static ssize_t pccard_store_cis(struct file *filp, struct kobject *kobj,struct pcmcia_socket *s;int error; +if (kernel_is_locked_down ("Direct PCMCIA CIS storage" , +LOCKDOWN_INTEGRITY )) +return -EPERM ; + s = to_socket(container_of(kobj, struct device, kobj));if (off)
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 17/27 Lock down TIOCSSERIAL
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Lock down TIOCSSERIAL as that can be used to change the ioport and irq settings on a serial port. This only appears to be an issue for the serial drivers that use the core serial code. All other drivers seem to either ignore attempts to change port/irq or give an error.
--- drivers/tty/serial/serial_core.c | 6 ++++++ 1 file changed, 6 insertions(+)
drivers/tty/serial/serial_core.c +6 -0
@@ -842,6 +842,12 @@ static int uart_set_info(struct tty_struct *tty, struct tty_port *port, new_flags = (__force upf_t )new_info->flags; old_custom_divisor = uport->custom_divisor; +if ((change_port || change_irq) && +kernel_is_locked_down ("Using TIOCSSERIAL to change device addresses, irqs and dma channels" ,LOCKDOWN_INTEGRITY )) { + retval = -EPERM ; + goto exit; + } +if (!capable (CAP_SYS_ADMIN )) { retval = -EPERM ; if (change_irq || change_port ||
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 18/27 Lock down module params that specify hardware parameters (eg. ioport)
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Provided an annotation for module parameters that specify hardware parameters (such as io ports, iomem addresses, irqs, dma channels, fixed dma buffers and other types).
--- kernel/params.c | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-)
kernel/params.c +21 -5
@@ -108,13 +108,19 @@ bool parameq(const char *a, const char *b)return parameqn (a, b,strlen (a)+1 ); } -static void param_check_unsafe (const struct kernel_param *kp) +static bool param_check_unsafe (const struct kernel_param *kp, +const char *doing) {if (kp->flags &KERNEL_PARAM_FL_UNSAFE ) {pr_notice ("Setting dangerous option %s - tainting kernel\n" , kp->name);add_taint (TAINT_USER ,LOCKDEP_STILL_OK ); } + +if (kp->flags &KERNEL_PARAM_FL_HWPARAM && +kernel_is_locked_down ("Command line-specified device addresses, irqs and dma channels" ,LOCKDOWN_INTEGRITY )) +return false; +return true; } static int parse_one(char *param,
@@ -144,8 +150,10 @@ static int parse_one(char *param,pr_debug ("handling %s with %p\n" , param, params[i].ops->set);kernel_param_lock (params[i].mod); -param_check_unsafe (¶ms[i]); - err = params[i].ops->set (val, ¶ms[i]); +if (param_check_unsafe (¶ms[i], doing)) + err = params[i].ops->set (val, ¶ms[i]); +else + err = -EPERM ;kernel_param_unlock (params[i].mod);return err; }
@@ -553,6 +561,12 @@ static ssize_t param_attr_show(struct module_attribute *mattr,return count; } +#ifdef CONFIG_MODULES +#define mod_name (mod) (mod)->name +#else +#define mod_name (mod) "unknown" +#endif +/* sysfs always hands a nul-terminated string in buf. We rely on that. */ static ssize_t param_attr_store(struct module_attribute *mattr, struct module_kobject *mk,
@@ -565,8 +579,10 @@ static ssize_t param_attr_store(struct module_attribute *mattr,return -EPERM ;kernel_param_lock (mk->mod); -param_check_unsafe (attribute->param); - err = attribute->param->ops->set (buf, attribute->param); +if (param_check_unsafe (attribute->param,mod_name (mk->mod))) + err = attribute->param->ops->set (buf, attribute->param); +else + err = -EPERM ;kernel_param_unlock (mk->mod);if (!err)return len;
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 19/27 x86/mmiotrace: Lock down the testmmiotrace module
In reply to Matthew GarrettFrom: David Howells <[email protected]>
The testmmiotrace module shouldn't be permitted when the kernel is locked down as it can be used to arbitrarily read and write MMIO space. 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 | 3 +++ 1 file changed, 3 insertions(+)
arch/x86/mm/testmmiotrace.c +3 -0
@@ -115,6 +115,9 @@ static int __init init(void) {unsigned long size = (read_far) ? (8 <<20 ) : (16 <<10 ); +if (kernel_is_locked_down ("MMIO trace testing" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (mmio_address ==0 ) {pr_err ("you have to use the module argument mmio_address.\n" );pr_err ("DO NOT LOAD THIS MODULE UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!\n" );
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
Re: [PATCH V32 19/27] x86/mmiotrace: Lock down the testmmiotrace module
Quoted 8 lines · On Wed, 3 Apr 2019 17:32:41 -0700 Matthew Garrett <[email protected]>…
From: 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.
Quoted 5 lines
Suggested-by Thomas Gleixner <[email protected]>Signed-off-by David Howells <[email protected]Signed-off-by Matthew Garrett <[email protected]>cc Thomas Gleixner <[email protected]>cc Steven Rostedt <[email protected]>
-- Steve
Quoted 21 lines
--- arch/x86/mm/testmmiotrace.c | 3 +++ 1 file changed, 3 insertions(+)arch/x86/mm/testmmiotrace.c +3
-0@@ -115,6 +115,9 @@ static int __init init(void) {unsigned long size = (read_far) ? (8 <<20 ) : (16 <<10 ); +if (kernel_is_locked_down ("MMIO trace testing" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +if (mmio_address ==0 ) {pr_err ("you have to use the module argument mmio_address.\n" );pr_err ("DO NOT LOAD THIS MODULE UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!\n" );
Re: [PATCH V32 19/27] x86/mmiotrace: Lock down the testmmiotrace module
In reply to Matthew GarrettQuoted 11 lines · Matthew Garrett
From: 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.
Suggested-by Thomas Gleixner <[email protected]>Signed-off-by David Howells <[email protected]Signed-off-by Matthew Garrett <[email protected]>
PATCH v32 20/27 Lock down /proc/kcore
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow access to /proc/kcore when the kernel is locked down to prevent access to cryptographic data. This is limited to lockdown confidentiality mode and is still permitted in integrity mode.
--- fs/proc/kcore.c | 2 ++ 1 file changed, 2 insertions(+)
fs/proc/kcore.c +2 -0
@@ -518,6 +518,8 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)static int open_kcore (struct inode *inode,struct file *filp) { +if (kernel_is_locked_down ("/proc/kcore" ,LOCKDOWN_CONFIDENTIALITY )) +return -EPERM ;if (!capable (CAP_SYS_RAWIO ))return -EPERM ;
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 21/27 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.
--- kernel/trace/trace_kprobe.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/trace/trace_kprobe.c +3 -0
@@ -420,6 +420,9 @@ static int __register_trace_kprobe(struct trace_kprobe *tk) {int i, ret; +if (kernel_is_locked_down ("Use of kprobes" ,LOCKDOWN_CONFIDENTIALITY )) +return -EPERM ; +if (trace_probe_is_registered (&tk->tp))return -EINVAL ;
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 22/27 bpf: Restrict bpf when kernel lockdown is in confidentiality mode
In reply to Matthew GarrettFrom: David Howells <[email protected]>
There are some bpf functions can be used to read kernel memory:bpf_probe_read, bpf_probe_write_user and bpf_trace_printk. These allow private keys in kernel memory (e.g. the hibernation image signing key) to be read by an eBPF program and kernel memory to be altered without restriction. Disable them if the kernel has been locked down in confidentiality mode.
--- kernel/trace/bpf_trace.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
kernel/trace/bpf_trace.c +11 -0
@@ -137,6 +137,9 @@ BPF_CALL_3(bpf_probe_read, void *, dst, u32, size, const void *, unsafe_ptr) {int ret; +if (kernel_is_locked_down ("BPF" ,LOCKDOWN_CONFIDENTIALITY )) +return -EINVAL ; + ret =probe_kernel_read (dst, unsafe_ptr, size);if (unlikely (ret <0 ))memset (dst,0 , size);
@@ -156,6 +159,8 @@ static const struct bpf_func_proto bpf_probe_read_proto = { BPF_CALL_3(bpf_probe_write_user, void *, unsafe_ptr, const void *, src, u32, size) { +if (kernel_is_locked_down ("BPF" ,LOCKDOWN_CONFIDENTIALITY )) +return -EINVAL ;/* * Ensure we're in user context which is safe for the helper to * run. This helper has no business in a kthread.
@@ -207,6 +212,9 @@ BPF_CALL_5(bpf_trace_printk, char *, fmt, u32, fmt_size, u64, arg1,char buf[64 ];int i; +if (kernel_is_locked_down ("BPF" ,LOCKDOWN_CONFIDENTIALITY )) +return -EINVAL ; +/* * bpf_check()->check_func_arg()->check_stack_boundary() * guarantees that fmt points to bpf program stack,
@@ -535,6 +543,9 @@ BPF_CALL_3(bpf_probe_read_str, void *, dst, u32, size, {int ret; +if (kernel_is_locked_down ("BPF" ,LOCKDOWN_CONFIDENTIALITY )) +return -EINVAL ; +/* * The strncpy_from_unsafe() call will likely not fill the entire * buffer, but that's okay in this circumstance as we're probing
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
Re: [PATCH V32 22/27] bpf: Restrict bpf when kernel lockdown is in confidentiality mode
+bpf list
Quoted 23 lines · Matthew Garrett
There are some bpf functions can be used to read kernel memory:
bpf_probe_read,bpf_probe_write_userandbpf_trace_printk. These allow private keys in kernel memory (e.g. the hibernation image signing key) to be read by an eBPF program and kernel memory to be altered without restriction. Disable them if the kernel has been locked down in confidentiality mode.Suggested-by Alexei Starovoitov <[email protected]>Signed-off-by David Howells <[email protected]>Signed-off-by Matthew Garrett <[email protected]>cc Chun-Yi Lee <[email protected]>cc Alexei Starovoitov <[email protected]>Cc Daniel Borkmann <[email protected]>--- kernel/trace/bpf_trace.c | 11 +++++++++++ 1 file changed, 11 insertions(+)kernel/trace/bpf_trace.c +0
-0
kernel/trace/bpf_trace.c BPF_CALL_3(bpf_probe_read, void *, dst, u32, size, const void *, unsafe_ptr) · line 145
Quoted 9 lines
kernel/trace/bpf_trace.c +3
-0@@ -137,6 +137,9 @@ BPF_CALL_3(bpf_probe_read, void *, dst, u32, size, const void *, unsafe_ptr) {int ret; +if (kernel_is_locked_down ("BPF" ,LOCKDOWN_CONFIDENTIALITY )) +return -EINVAL ; + ret =probe_kernel_read (dst, unsafe_ptr, size);if (unlikely (ret <0 ))memset (dst,0 , size);
This looks wrong. bpf_probe_read_proto is declared with an ARG_PTR_TO_UNINIT_MEM argument, so if you don't do a "memset(dst, 0, size);" like in the probe_kernel_read() error path, the BPF program can read uninitialized memory.
PATCH v32 23/27 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.
--- kernel/events/core.c | 6 ++++++ 1 file changed, 6 insertions(+)
kernel/events/core.c +6 -0
@@ -10461,6 +10461,12 @@ SYSCALL_DEFINE5(perf_event_open,return -EINVAL ; } +if ((attr.sample_type &PERF_SAMPLE_REGS_INTR ) && +kernel_is_locked_down ("PERF_SAMPLE_REGS_INTR" , +LOCKDOWN_CONFIDENTIALITY )) +/* REGS_INTR can leak data, lockdown must prevent this */ +return -EPERM ; +/* Only privileged users can get physical addresses */ if ((attr.sample_type &PERF_SAMPLE_PHYS_ADDR ) &&perf_paranoid_kernel () && !capable (CAP_SYS_ADMIN ))
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 24/27 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 | 7 +++- security/integrity/ima/ima.h | 2 ++ security/integrity/ima/ima_main.c | 2 +- security/integrity/ima/ima_policy.c | 50 +++++++++++++++++++++++++++++ 5 files changed, 68 insertions(+), 2 deletions(-)
include/linux/ima.h +9 -0
@@ -127,4 +127,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 +6 -1
@@ -240,7 +240,12 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd, ret =0 ; -if (kernel_is_locked_down (reason,LOCKDOWN_INTEGRITY )) { +/* 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 ) && +kernel_is_locked_down (reason,LOCKDOWN_INTEGRITY )) { ret = -EPERM ; goto out; }
security/integrity/ima/ima.h +2 -0
@@ -115,6 +115,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
@@ -442,7 +442,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.21.0.392.gf8f6787159e-goog
PATCH v32 25/27 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
--- security/lock_down.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
security/lock_down.c +2 -2
@@ -70,8 +70,8 @@ bool __kernel_is_locked_down(const char *what, enum lockdown_level level, bool first) {if ((kernel_locked_down >= level) && what && first) -pr_notice ("Lockdown: %s is restricted; see man kernel_lockdown.7\n" , - what); +pr_notice ("Lockdown: %s: %s is restricted; see man kernel_lockdown.7\n" , + current->comm, what);return (kernel_locked_down >= level); }EXPORT_SYMBOL (__kernel_is_locked_down);
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 26/27 debugfs: Restrict debugfs when the kernel is locked down
In reply to Matthew GarrettFrom: David Howells <[email protected]>
Disallow opening of debugfs files that might be used to muck around when the kernel is locked down as various drivers give raw access to hardware through debugfs. Given the effort of auditing all 2000 or so files and manually fixing each one as necessary, I've chosen to apply a heuristic instead. The following changes are made:
(1) chmod and chown are disallowed on debugfs objects (though the root dir can be modified by mount and remount, but I'm not worried about that).
(2) When the kernel is locked down, only files with the following criteria are permitted to be opened:
- The file must have mode 00444
- The file must not have ioctl methods
- The file must not have mmap
(3) When the kernel is locked down, files may only be opened for reading.
Normal device interaction should be done through configfs, sysfs or a miscdev, not debugfs.
Note that this makes it unnecessary to specifically lock down show_dsts(), show_devs() and show_call() in the asus-wmi driver.
I would actually prefer to lock down all files by default and have the the files unlocked by the creator. This is tricky to manage correctly, though, as there are 19 creation functions and ~1600 call sites (some of them in loops scanning tables).
--- fs/debugfs/file.c | 28 ++++++++++++++++++++++++++++ fs/debugfs/inode.c | 30 ++++++++++++++++++++++++++++-- 2 files changed, 56 insertions(+), 2 deletions(-)
fs/debugfs/file.c +28 -0
@@ -136,6 +136,25 @@ void debugfs_file_put(struct dentry *dentry) }EXPORT_SYMBOL_GPL (debugfs_file_put); +/* +* Only permit access to world-readable files when the kernel is locked down. +* We also need to exclude any file that has ways to write or alter it as root +* can bypass the permissions check. +*/ +static bool debugfs_is_locked_down (struct inode *inode, +struct file *filp, +const struct file_operations *real_fops) +{ +if ((inode->i_mode &07777 ) ==0444 && + !(filp->f_mode &FMODE_WRITE ) && + !real_fops->unlocked_ioctl && + !real_fops->compat_ioctl && + !real_fops->mmap) +return false; + +return kernel_is_locked_down ("debugfs" ,LOCKDOWN_INTEGRITY ); +} +static int open_proxy_open (struct inode *inode,struct file *filp) {struct dentry *dentry =F_DENTRY (filp);
@@ -147,6 +166,11 @@ static int open_proxy_open(struct inode *inode, struct file *filp)return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); + + r = -EPERM ; +if (debugfs_is_locked_down (inode, filp, real_fops)) + goto out; + real_fops =fops_get (real_fops);if (!real_fops) {/* Huh? Module did not clean up after itself at exit? */
@@ -272,6 +296,10 @@ static int full_proxy_open(struct inode *inode, struct file *filp)return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); + r = -EPERM ; +if (debugfs_is_locked_down (inode, filp, real_fops)) + goto out; + real_fops =fops_get (real_fops);if (!real_fops) {/* Huh? Module did not cleanup after itself at exit? */
fs/debugfs/inode.c +28 -2
@@ -32,6 +32,31 @@ static struct vfsmount *debugfs_mount;static int debugfs_mount_count;static bool debugfs_registered; +/* +* Don't allow access attributes to be changed whilst the kernel is locked down +* so that we can use the file mode as part of a heuristic to determine whether +* to lock down individual files. +*/ +static int debugfs_setattr (struct dentry *dentry,struct iattr *ia) +{ +if ((ia->ia_valid & (ATTR_MODE |ATTR_UID |ATTR_GID )) && +kernel_is_locked_down ("debugfs" ,LOCKDOWN_INTEGRITY )) +return -EPERM ; +return simple_setattr (dentry, ia); +} + +static const struct inode_operations debugfs_file_inode_operations = { + .setattr = debugfs_setattr, +}; +static const struct inode_operations debugfs_dir_inode_operations = { + .lookup = simple_lookup, + .setattr = debugfs_setattr, +}; +static const struct inode_operations debugfs_symlink_inode_operations = { + .get_link = simple_get_link, + .setattr = debugfs_setattr, +}; +static struct inode *debugfs_get_inode (struct super_block *sb) {struct inode *inode =new_inode (sb);
@@ -356,6 +381,7 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode, inode->i_mode = mode; inode->i_private = data; + inode->i_op = &debugfs_file_inode_operations; inode->i_fop = proxy_fops; dentry->d_fsdata = (void *)((unsigned long )real_fops |DEBUGFS_FSDATA_IS_REAL_FOPS_BIT );
@@ -513,7 +539,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) */
@@ -608,7 +634,7 @@ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,return failed_creating (dentry); } inode->i_mode =S_IFLNK |S_IRWXUGO ; - inode->i_op = &simple_symlink_inode_operations; + inode->i_op = &debugfs_symlink_inode_operations; inode->i_link = link;d_instantiate (dentry, inode);return end_creating (dentry);
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
PATCH v32 27/27 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().
--- fs/tracefs/inode.c | 40 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-)
fs/tracefs/inode.c +39 -1
@@ -31,6 +31,21 @@ 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; + +if (!dentry) +return -EINVAL ; + +if (kernel_is_locked_down ("tracefs" ,LOCKDOWN_CONFIDENTIALITY )) +return -EPERM ; + + real_fops = dentry->d_fsdata; +return real_fops->open (inode, filp); +} +static ssize_t default_read_file (struct file *file,char __user *buf,size_t count,loff_t *ppos) {
@@ -50,6 +65,13 @@ static const struct file_operations tracefs_file_operations = { .llseek = noop_llseek, }; +static const struct file_operations tracefs_proxy_file_operations = { + .read = default_read_file, + .write = default_write_file, + .open = default_open_file, + .llseek = noop_llseek, +}; + static struct tracefs_dir_ops { int (*mkdir)(const char *name); int (*rmdir)(const char *name);
@@ -225,6 +247,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;
@@ -260,6 +288,7 @@ static int tracefs_show_options(struct seq_file *m, struct dentry *root)static const struct super_operations tracefs_super_operations = { .statfs = simple_statfs, + .destroy_inode = tracefs_destroy_inode, .remount_fs = tracefs_remount, .show_options = tracefs_show_options, };
@@ -393,6 +422,7 @@ struct dentry *tracefs_create_file(const char *name, umode_t mode, {struct dentry *dentry;struct inode *inode; +struct file_operations *proxy_fops;if (!(mode &S_IFMT )) mode |=S_IFREG ;
@@ -406,8 +436,16 @@ 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 (!proxy_fops) +return failed_creating (dentry); + + dentry->d_fsdata = fops ? (void *)fops : + (void *)&tracefs_file_operations; +memcpy (proxy_fops, dentry->d_fsdata,sizeof (struct file_operations )); + 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);
Signature · 1 line
2.21.0.392.gf8f6787159e-goog
Re: [PATCH V32 27/27] tracefs: Restrict tracefs when the kernel is locked down
fs/tracefs/inode.c static int tracefs_apply_options(struct super_block *sb) · line 252
Quoted 3 lines · On Wed, 3 Apr 2019 17:32:49 -0700 Matthew Garrett <[email protected]>…
fs/tracefs/inode.c +3
-0+static void tracefs_destroy_inode (struct inode *inode) +{ + if S_ISREG(inode->i_mode)
Can we please put parenthesis around the condition. I know that the macro has them, but no other place in the kernel plays such a trick.
if (S_ISREG(inode->i_mode))
Other than that, the rest looks good.
-- Steve
Quoted 40 lines
fs/tracefs/inode.c +14
-1+kfree (inode->i_fop); +} +static int tracefs_remount (struct super_block *sb,int *flags,char *data) {int err;@@ -260,6 +288,7 @@ static int tracefs_show_options(struct seq_file *m, struct dentry *root)static const struct super_operations tracefs_super_operations = { .statfs = simple_statfs, + .destroy_inode = tracefs_destroy_inode, .remount_fs = tracefs_remount, .show_options = tracefs_show_options, };@@ -393,6 +422,7 @@ struct dentry *tracefs_create_file(const char *name, umode_t mode, {struct dentry *dentry;struct inode *inode; +struct file_operations *proxy_fops;if (!(mode &S_IFMT )) mode |=S_IFREG ;@@ -406,8 +436,16 @@ 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 (!proxy_fops) +return failed_creating (dentry); + + dentry->d_fsdata = fops ? (void *)fops : + (void *)&tracefs_file_operations; +memcpy (proxy_fops, dentry->d_fsdata,sizeof (struct file_operations )); + 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);
Re: [PATCH V32 27/27] tracefs: Restrict tracefs when the kernel is locked down
Quoted 11 lines · Steven Rostedt
fs/tracefs/inode.c static int tracefs_apply_options(struct super_block *sb) · line 252
Quoted 3 lines · On Wed, 3 Apr 2019 17:32:49 -0700 Matthew Garrett <[email protected]>…
fs/tracefs/inode.c +3
-0+static void tracefs_destroy_inode (struct inode *inode) +{ + if S_ISREG(inode->i_mode)Can we please put parenthesis around the condition. I know that the macro has them, but no other place in the kernel plays such a trick.
Ha, I've been spending too much time in Go lately. Fixed.