Skip to contentSkip to conversation

Lockdown patches for 5.2

PATCH In review Matthew Garrett 9 participants 45 messages Apr 4, 2019 – May 3, 2019

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

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.

#1 lore raw

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
new file mode 100644
index 000000000000..5bd51e20917a
@@ -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
index 91c0251fdb86..594d268d92ba 100644
@@ -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
index 8f0e68e250a7..30cf695719d5 100644
@@ -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
index 13537a49ae97..b290946341a4 100644
@@ -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
index e2e80ca3165a..4c6cca9681c7 100644
@@ -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
index 1d6463fb1450..593ff231eac6 100644
@@ -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
index c598b904938f..5ff090149c88 100644
@@ -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
#2 lore raw

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
new file mode 100644
index 000000000000..5bd51e20917a
@@ -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
#3 lore raw

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
#4 lore raw

Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image

In reply to Andrew Donnellan
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.

#5 lore raw

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

#6 lore raw

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

#7 lore raw

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
#8 lore raw

Re: [PATCH V32 01/27] Add the ability to lock down access to the running kernel image

In reply to 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.

maintainer
#9 lore raw

Re: [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]>
#10 lore raw

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.

maintainer
#11 lore raw

Re: [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]>
#12 lore raw

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_feature true|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.

#13 lore raw

PATCH v32 2/27 Enforce module signatures if the kernel is locked down

In reply to Matthew Garrett

From: 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
index 2ad1b5239910..deea9d2763f8 100644
@@ -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
#14 lore raw

PATCH v32 3/27 Restrict /dev/{mem,kmem,port} when the kernel is locked down

In reply to Matthew Garrett

From: 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
index b08dc50f9f26..67b85939b1bd 100644
@@ -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
#15 lore raw

PATCH v32 4/27 kexec_load: Disable at runtime if the kernel is locked down

In reply to Matthew Garrett

From: 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
index 68559808fdfa..57047acc9a36 100644
@@ -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
#16 lore raw

PATCH v32 5/27 Copy secure_boot flag in boot params across kexec reboot

In reply to Matthew Garrett

From: 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
index 278cd07228dd..d49554b948fd 100644
@@ -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
#17 lore raw

PATCH v32 6/27 kexec_file: split KEXEC_VERIFY_SIG into KEXEC_SIG and KEXEC_SIG_FORCE

In reply to Matthew Garrett

From: 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
index 4b4a7f32b68e..735d04a4b18f 100644
@@ -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
index d178650fd524..4473cea1e877 100644
@@ -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
index b9b1bc5f9669..58b27c7bdc2b 100644
@@ -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
#18 lore raw

PATCH v32 7/27 kexec_file: Restrict at runtime if the kernel is locked down

In reply to Matthew Garrett

From: 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
index 67f3a866eabe..a1cc37c8b43b 100644
@@ -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
#19 lore raw

PATCH v32 8/27 hibernate: Disable when the kernel is locked down

In reply to 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.

---
 kernel/power/hibernate.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/power/hibernate.c +2 -1
index abef759de7c8..928b198cfa26 100644
@@ -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
#20 lore raw

PATCH v32 9/27 uswsusp: Disable when the kernel is locked down

In reply to Matthew Garrett

From: 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
index 2d8b60a3c86b..99e13fd13237 100644
@@ -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
#21 lore raw

PATCH v32 10/27 PCI: Lock down BAR access when the kernel is locked down

In reply to 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.

---
 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
index 9ecfe13157c0..59d02088945e 100644
@@ -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
index 6fa1627ce08d..85769f222b6d 100644
@@ -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
index d96626c614f5..0669cb09e792 100644
@@ -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
#22 lore raw

PATCH v32 11/27 x86: Lock down IO port access when the kernel is locked down

In reply to 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.

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
index 0fe1c8782208..febbd7eb847c 100644
@@ -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
Reviewed-by on v32 11/27
#23 lore raw

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.

#24 lore raw

PATCH v32 12/27 x86/msr: Restrict MSR access when the kernel is locked down

In reply to Matthew Garrett

From: 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
index 4588414e2561..731be1be52b6 100644
@@ -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
#25 lore raw

PATCH v32 13/27 ACPI: Limit access to custom_method when the kernel is locked down

In reply to Matthew Garrett

From: 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
index 4451877f83b6..37de3cd84493 100644
@@ -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
#26 lore raw

PATCH v32 14/27 acpi: Ignore acpi_rsdp kernel param when the kernel has been locked down

In reply to 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.

---
 drivers/acpi/osl.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/acpi/osl.c +2 -1
index f29e427d0d1d..cd5bba7b8eb3 100644
@@ -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
#27 lore raw

PATCH v32 15/27 acpi: Disable ACPI table override if the kernel is locked down

In reply to Matthew Garrett

From: 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
index 48eabb6c2d4f..0dc561210c86 100644
@@ -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
#28 lore raw

PATCH v32 16/27 Prohibit PCMCIA CIS storage when the kernel is locked down

In reply to Matthew Garrett

From: 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
index ac0672b8dfca..9e23300a55e5 100644
@@ -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
#29 lore raw

PATCH v32 17/27 Lock down TIOCSSERIAL

In reply to Matthew Garrett

From: 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
index d4cca5bdaf1c..65b67f0d4386 100644
@@ -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
#30 lore raw

PATCH v32 18/27 Lock down module params that specify hardware parameters (eg. ioport)

In reply to Matthew Garrett

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).

---
 kernel/params.c | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)
kernel/params.c +21 -5
index ce89f757e6da..da1297f7cc26 100644
@@ -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(&params[i]);
-			err = params[i].ops->set(val, &params[i]);
+			if (param_check_unsafe(&params[i], doing))
+				err = params[i].ops->set(val, &params[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
#31 lore raw

PATCH v32 19/27 x86/mmiotrace: Lock down the testmmiotrace module

In reply to 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.

---
 arch/x86/mm/testmmiotrace.c | 3 +++
 1 file changed, 3 insertions(+)
arch/x86/mm/testmmiotrace.c +3 -0
index f6ae6830b341..9e8ad665f354 100644
@@ -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
maintainer Acked-by on v32 19/27
#32 lore raw

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

-- Steve

Quoted 21 lines
cc Ingo Molnar <[email protected]>
cc "H. Peter Anvin" <[email protected]>
---
 arch/x86/mm/testmmiotrace.c | 3 +++
 1 file changed, 3 insertions(+)
arch/x86/mm/testmmiotrace.c +3 -0
index f6ae6830b341..9e8ad665f354 100644
@@ -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");
Reviewed-by on v32 19/27
#33 lore raw

Re: [PATCH V32 19/27] x86/mmiotrace: Lock down the testmmiotrace module

In reply to Matthew Garrett
Quoted 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.

#34 lore raw

PATCH v32 20/27 Lock down /proc/kcore

In reply to Matthew Garrett

From: 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
index bbcc185062bb..1c556a453569 100644
@@ -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
#35 lore raw

PATCH v32 21/27 Lock down tracing and perf kprobes when in confidentiality mode

In reply to Matthew Garrett

From: 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
index d5fb09ebba8b..5c70acd80344 100644
@@ -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
#36 lore raw

PATCH v32 22/27 bpf: Restrict bpf when kernel lockdown is in confidentiality mode

In reply to Matthew Garrett

From: 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
index 8b068adb9da1..9e8eda605b5e 100644
@@ -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
#37 lore raw

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_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 +0 -0
index 8b068adb9da1..9e8eda605b5e 100644

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.

#38 lore raw

PATCH v32 23/27 Lock down perf when in confidentiality mode

In reply to Matthew Garrett

From: David Howells <[email protected]>

Disallow the use of certain perf facilities that might allow userspace to access kernel data.

Cc Peter Zijlstra <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc Arnaldo Carvalho de Melo <[email protected]>
---
 kernel/events/core.c | 6 ++++++
 1 file changed, 6 insertions(+)
kernel/events/core.c +6 -0
index 3cd13a30f732..6ad3d83c091c 100644
@@ -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
#39 lore raw

PATCH v32 24/27 kexec: Allow kexec_file() with appropriate IMA policy when locked down

In reply to Matthew Garrett

Systems 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
index b5e16b8c50b7..60007b86f4fc 100644
@@ -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
index a1cc37c8b43b..7599039623a7 100644
@@ -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
index cc12f3449a72..fe03cc6f1ca4 100644
@@ -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
index 4ffac4f5c647..106f06dee9d1 100644
@@ -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
#40 lore raw

PATCH v32 25/27 lockdown: Print current->comm in restriction messages

In reply to Matthew Garrett

Print the content of current->comm in messages generated by lockdown to indicate a restriction that was hit. This makes it a bit easier to find out what caused the message.

The message now patterned something like:

Lockdown: <comm>: <what> is restricted; see man kernel_lockdown.7

---
 security/lock_down.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
security/lock_down.c +2 -2
index 9913fff09ad0..2659722784cc 100644
@@ -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
#41 lore raw

PATCH v32 26/27 debugfs: Restrict debugfs when the kernel is locked down

In reply to Matthew Garrett

From: 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
index 4fce1da7db23..2d18e7711fca 100644
@@ -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
index 13b01351dd1c..4b877cb1431d 100644
@@ -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
#42 lore raw

PATCH v32 27/27 tracefs: Restrict tracefs when the kernel is locked down

In reply to Matthew Garrett

Tracefs 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
index 7098c49f3693..576327ffd9d1 100644
@@ -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
maintainer Reviewed-by on v32 27/27
#43 lore raw

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);
#44 lore raw

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.