Skip to contentSkip to conversation

Lockdown as an LSM

PATCH Superseded Matthew Garrett 9 participants 58 messages Jun 21, 2019 – Jun 29, 2019

Subsystems (37)

v33 of 40 Superseded Latest is v40 →

lore
Share & tools
lore
#0 lore raw

v33 cover Lockdown as an LSM

Hi James,

Let's see how this one goes. I've moved the lockdown code into an LSM hook and provided an internal enum of lockdown reasons that LSMs can either group or expose at whatever level of granularity is appropriate. I've also included a static LSM that mimics the behaviour of the existing patchset. I think there's a reasonable discussion to have about what sort of granularity other LSMs might want to offer, but I don't think that necessarily needs to be a blocker to merging this.

As with the last implementation, this can be enabled via static kernel configuration, the kernel command line or via securityfs, depending on usecase. Distributions may wish to tie it to UEFI Secure Boot state, but we can save that conversation to later.

Thoughts?

#1 lore raw

PATCH v33 1/30 security: Support early LSMs

The lockdown module is intended to allow for kernels to be locked down early in boot - sufficiently early that we don't have the ability to kmalloc() yet. Add support for early initialisation of some LSMs, and then add them to the list of names when we do full initialisation later.

---
 include/asm-generic/vmlinux.lds.h |  8 +++++-
 include/linux/lsm_hooks.h         |  6 ++++
 include/linux/security.h          |  1 +
 init/main.c                       |  1 +
 security/security.c               | 48 +++++++++++++++++++++++++------
 5 files changed, 54 insertions(+), 10 deletions(-)
include/asm-generic/vmlinux.lds.h +7 -1
index f8f6f04c4453..e1963352fdb6 100644
@@ -208,8 +208,13 @@
 			__start_lsm_info = .;				\
 			KEEP(*(.lsm_info.init))				\
 			__end_lsm_info = .;
+#define EARLY_LSM_TABLE()	. = ALIGN(8);				\
+			__start_early_lsm_info = .;			\
+			KEEP(*(.early_lsm_info.init))			\
+			__end_early_lsm_info = .;
 #else
 #define LSM_TABLE()
+#define EARLY_LSM_TABLE()
 #endif
 
 #define ___OF_TABLE(cfg, name)	_OF_TABLE_##cfg(name)
@@ -610,7 +615,8 @@
 	ACPI_PROBE_TABLE(irqchip)					\
 	ACPI_PROBE_TABLE(timer)						\
 	EARLYCON_TABLE()						\
-	LSM_TABLE()
+	LSM_TABLE()							\
+	EARLY_LSM_TABLE()
 
 #define INIT_TEXT							\
 	*(.init.text .init.text.*)					\
include/linux/lsm_hooks.h +6 -0
index a240a3fc5fc4..66fd1eac7a32 100644
@@ -2085,12 +2085,18 @@ struct lsm_info {
 };
 
 extern struct lsm_info __start_lsm_info[], __end_lsm_info[];
+extern struct lsm_info __start_early_lsm_info[], __end_early_lsm_info[];
 
 #define DEFINE_LSM(lsm)							\
 	static struct lsm_info __lsm_##lsm				\
 		__used __section(.lsm_info.init)			\
 		__aligned(sizeof(unsigned long))
 
+#define DEFINE_EARLY_LSM(lsm)						\
+	static struct lsm_info __early_lsm_##lsm			\
+		__used __section(.early_lsm_info.init)			\
+		__aligned(sizeof(unsigned long))
+
 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
 /*
  * Assuring the safety of deleting a security module is up to
include/linux/security.h +1 -0
index 49f2685324b0..1bb6fb2f1523 100644
@@ -194,6 +194,7 @@ int unregister_lsm_notifier(struct notifier_block *nb);
 
 /* prototypes */
 extern int security_init(void);
+extern int early_security_init(void);
 
 /* Security operations */
 int security_binder_set_context_mgr(struct task_struct *mgr);
init/main.c +1 -0
index 598e278b46f7..f3faeb89c75f 100644
@@ -563,6 +563,7 @@ asmlinkage __visible void __init start_kernel(void)
 	boot_cpu_init();
 	page_address_init();
 	pr_notice("%s", linux_banner);
+	early_security_init();
 	setup_arch(&command_line);
 	/*
 	 * Set up the the initial canary and entropy after arch
security/security.c +39 -9

87 lines not on this page · raw message

Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#2 lore raw

Re: [PATCH V33 01/30] security: Support early LSMs

Quoted 4 lines · Matthew Garrett

The lockdown module is intended to allow for kernels to be locked down early in boot - sufficiently early that we don't have the ability to kmalloc() yet. Add support for early initialisation of some LSMs, and then add them to the list of names when we do full initialisation later.

So, if I'm reading correctly, these "early LSMs":

- start up before even boot parameter parsing has happened
- have their position in the LSM ordering ignored
- are initialized in boot order
- cannot use kmalloc, as well as probably lots of other things

Quoted 113 lines
---
 include/asm-generic/vmlinux.lds.h |  8 +++++-
 include/linux/lsm_hooks.h         |  6 ++++
 include/linux/security.h          |  1 +
 init/main.c                       |  1 +
 security/security.c               | 48 +++++++++++++++++++++++++------
 5 files changed, 54 insertions(+), 10 deletions(-)
include/asm-generic/vmlinux.lds.h +7 -1
index f8f6f04c4453..e1963352fdb6 100644
@@ -208,8 +208,13 @@
 			__start_lsm_info = .;				\
 			KEEP(*(.lsm_info.init))				\
 			__end_lsm_info = .;
+#define EARLY_LSM_TABLE()	. = ALIGN(8);				\
+			__start_early_lsm_info = .;			\
+			KEEP(*(.early_lsm_info.init))			\
+			__end_early_lsm_info = .;
 #else
 #define LSM_TABLE()
+#define EARLY_LSM_TABLE()
 #endif
 
 #define ___OF_TABLE(cfg, name)	_OF_TABLE_##cfg(name)
@@ -610,7 +615,8 @@
 	ACPI_PROBE_TABLE(irqchip)					\
 	ACPI_PROBE_TABLE(timer)						\
 	EARLYCON_TABLE()						\
-	LSM_TABLE()
+	LSM_TABLE()							\
+	EARLY_LSM_TABLE()
 
 #define INIT_TEXT							\
 	*(.init.text .init.text.*)					\
include/linux/lsm_hooks.h +6 -0
index a240a3fc5fc4..66fd1eac7a32 100644
@@ -2085,12 +2085,18 @@ struct lsm_info {
 };
 
 extern struct lsm_info __start_lsm_info[], __end_lsm_info[];
+extern struct lsm_info __start_early_lsm_info[], __end_early_lsm_info[];
 
 #define DEFINE_LSM(lsm)							\
 	static struct lsm_info __lsm_##lsm				\
 		__used __section(.lsm_info.init)			\
 		__aligned(sizeof(unsigned long))
 
+#define DEFINE_EARLY_LSM(lsm)						\
+	static struct lsm_info __early_lsm_##lsm			\
+		__used __section(.early_lsm_info.init)			\
+		__aligned(sizeof(unsigned long))
+
 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
 /*
  * Assuring the safety of deleting a security module is up to
include/linux/security.h +1 -0
index 49f2685324b0..1bb6fb2f1523 100644
@@ -194,6 +194,7 @@ int unregister_lsm_notifier(struct notifier_block *nb);
 
 /* prototypes */
 extern int security_init(void);
+extern int early_security_init(void);
 
 /* Security operations */
 int security_binder_set_context_mgr(struct task_struct *mgr);
init/main.c +1 -0
index 598e278b46f7..f3faeb89c75f 100644
@@ -563,6 +563,7 @@ asmlinkage __visible void __init start_kernel(void)
 	boot_cpu_init();
 	page_address_init();
 	pr_notice("%s", linux_banner);
+	early_security_init();
 	setup_arch(&command_line);
 	/*
 	 * Set up the the initial canary and entropy after arch
security/security.c +3 -3
index 23cbb1a295a3..2a6672c9e72f 100644
@@ -37,6 +37,7 @@
 
 /* How many LSMs were built into the kernel? */
 #define LSM_COUNT (__end_lsm_info - __start_lsm_info)
+#define EARLY_LSM_COUNT (__end_early_lsm_info - __start_early_lsm_info)
 
 struct security_hook_heads security_hook_heads __lsm_ro_after_init;
 static ATOMIC_NOTIFIER_HEAD(lsm_notifier_chain);
@@ -281,6 +282,8 @@ static void __init ordered_lsm_parse(const char *order, const char *origin)
 static void __init lsm_early_cred(struct cred *cred);
 static void __init lsm_early_task(struct task_struct *task);
 
+static int lsm_append(const char *new, char **result);
+
 static void __init ordered_lsm_init(void)
 {
 	struct lsm_info **lsm;
@@ -327,15 +330,11 @@ static void __init ordered_lsm_init(void)
 	kfree(ordered_lsms);
 }
 
-/**
- * security_init - initializes the security framework
- *

security/security.c static void __init ordered_lsm_init(void) · line 339

Quoted 10 lines
security/security.c +2 -3
- * This should be called early in the kernel initialization sequence.
- */
-int __init security_init(void)
+int __init early_security_init(void)
 {
 	int i;
 	struct hlist_head *list = (struct hlist_head *) &security_hook_heads;
+	struct lsm_info *lsm;
 
 	pr_info("Security Framework initializing\n");

I'd rather this was kept in security_init() since it's the string to search for when debugging normal LSM initialization.

security/security.c int __init security_init(void) · line 349

Quoted 10 lines
security/security.c +5 -0
@@ -343,6 +342,30 @@ int __init security_init(void)
 	     i++)
 		INIT_HLIST_HEAD(&list[i]);
 
+	for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {
+		if (!lsm->enabled)
+			lsm->enabled = &lsm_enabled_true;
+		initialize_lsm(lsm);
+	}

This should call prepare_lsm() before initialize_lsm(). While not needed for this specific LSM, it would be nice to at least do the blog size calculations and keep everything the same as other LSMs.

Quoted 4 lines
security/security.c +4 -0
+
+	return 0;
+}
+

security/security.c int __init security_init(void) · line 363

Quoted 10 lines
security/security.c +10 -0
+/**
+ * security_init - initializes the security framework
+ *
+ * This should be called early in the kernel initialization sequence.
+ */
+int __init security_init(void)
+{
+	struct lsm_info *lsm;
+
+	/* Append the names of the early LSM modules now */

I would clarify this comment more: "... that kmalloc() is available."

Quoted 38 lines
security/security.c +15 -3
+	for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {
+		if (lsm->enabled)
+			lsm_append(lsm->name, &lsm_names);
+	}
+
 	/* Load LSMs in specified order. */
 	ordered_lsm_init();
 
@@ -388,7 +411,7 @@ static bool match_last_lsm(const char *list, const char *lsm)
 	return !strcmp(last, lsm);
 }
 
-static int lsm_append(char *new, char **result)
+static int lsm_append(const char *new, char **result)
 {
 	char *cp;
 
@@ -426,8 +449,15 @@ void __init security_add_hooks(struct security_hook_list *hooks, int count,
 		hooks[i].lsm = lsm;
 		hlist_add_tail_rcu(&hooks[i].list, hooks[i].head);
 	}
-	if (lsm_append(lsm, &lsm_names) < 0)
-		panic("%s - Cannot get early memory.\n", __func__);
+
+	/*
+	 * Don't try to append during early_security_init(), we'll come back
+	 * and fix this up afterwards.
+	 */
+	if (slab_is_available()) {
+		if (lsm_append(lsm, &lsm_names) < 0)
+			panic("%s - Cannot get early memory.\n", __func__);
+	}
 }
 
 int call_lsm_notifier(enum lsm_event event, void *data)
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
Signature · 1 line
Kees Cook
#3 lore raw

Re: [PATCH V33 01/30] security: Support early LSMs

Quoted 7 lines · Kees Cook
Quoted 4 lines · Matthew Garrett

The lockdown module is intended to allow for kernels to be locked down early in boot - sufficiently early that we don't have the ability to kmalloc() yet. Add support for early initialisation of some LSMs, and then add them to the list of names when we do full initialisation later.

Quoted 6 lines

So, if I'm reading correctly, these "early LSMs":

- start up before even boot parameter parsing has happened
- have their position in the LSM ordering ignored
- are initialized in boot order
- cannot use kmalloc, as well as probably lots of other things

Accurate. I've expanded the description.

Quoted 4 lines
Quoted 1 line
      pr_info("Security Framework initializing\n");

I'd rather this was kept in security_init() since it's the string to search for when debugging normal LSM initialization.

Ok.

Quoted 5 lines
Quoted 5 lines
security/security.c +0 -0
@@ -343,6 +342,30 @@ int __init security_init(void)
           i++)
              INIT_HLIST_HEAD(&list[i]);
 
Quoted 9 lines

security/security.c int __init security_init(void) · line 349

Quoted 5 lines
security/security.c +5 -0
+     for (lsm = __start_early_lsm_info; lsm < __end_early_lsm_info; lsm++) {
+             if (!lsm->enabled)
+                     lsm->enabled = &lsm_enabled_true;
+             initialize_lsm(lsm);
+     }

This should call prepare_lsm() before initialize_lsm(). While not needed for this specific LSM, it would be nice to at least do the blog size calculations and keep everything the same as other LSMs.

Ok.

Quoted 8 lines
Quoted 8 lines
security/security.c +8 -0
+
+     return 0;
+}
+
+/**
+ * security_init - initializes the security framework
+ *
+ * This should be called early in the kernel initialization sequence.
Quoted 8 lines

security/security.c int __init security_init(void) · line 363

Quoted 6 lines
security/security.c +6 -0
+ */
+int __init security_init(void)
+{
+     struct lsm_info *lsm;
+
+     /* Append the names of the early LSM modules now */

I would clarify this comment more: "... that kmalloc() is available."

Ok,

maintainer
#4 lore raw

Re: [PATCH V33 01/30] security: Support early LSMs

In reply to Matthew Garrett
Quoted 5 lines · Matthew Garrett

The lockdown module is intended to allow for kernels to be locked down early in boot - sufficiently early that we don't have the ability to kmalloc() yet. Add support for early initialisation of some LSMs, and then add them to the list of names when we do full initialisation later.

I'm confused. What does it even mean to lock down the kernel before we're ready to run userspace code? We can't possibly be attacked by user code before there is any to attack us.

Am I missing something here?

--Andy

#5 lore raw

Re: [PATCH V33 01/30] security: Support early LSMs

Quoted 4 lines · Andy Lutomirski
Quoted 1 line · Matthew Garrett
Quoted 8 lines
Quoted 4 lines

The lockdown module is intended to allow for kernels to be locked down early in boot - sufficiently early that we don't have the ability to kmalloc() yet. Add support for early initialisation of some LSMs, and then add them to the list of names when we do full initialisation later.

I'm confused. What does it even mean to lock down the kernel before we're ready to run userspace code? We can't possibly be attacked by user code before there is any to attack us.

Certain kernel parameters can be disabled by lockdown, so we want to have policy available before that parsing happens.

#6 lore raw

PATCH v33 2/30 security: Add a "locked down" LSM hook

In reply to Matthew Garrett

Add a mechanism to allow LSMs to make a policy decision around whether kernel functionality that would allow tampering with or examining the runtime state of the kernel should be permitted.

---
 include/linux/lsm_hooks.h |  2 ++
 include/linux/security.h  | 11 +++++++++++
 security/security.c       |  6 ++++++
 3 files changed, 19 insertions(+)
include/linux/lsm_hooks.h +2 -0
index 66fd1eac7a32..df2aebc99838 100644
@@ -1790,6 +1790,7 @@ union security_list_options {
 	int (*bpf_prog_alloc_security)(struct bpf_prog_aux *aux);
 	void (*bpf_prog_free_security)(struct bpf_prog_aux *aux);
 #endif /* CONFIG_BPF_SYSCALL */
+	int (*locked_down)(enum lockdown_reason what);
 };
 
 struct security_hook_heads {
@@ -2027,6 +2028,7 @@ struct security_hook_heads {
 	struct hlist_head bpf_prog_alloc_security;
 	struct hlist_head bpf_prog_free_security;
 #endif /* CONFIG_BPF_SYSCALL */
+	struct hlist_head locked_down;
 } __randomize_layout;
 
 /*
include/linux/security.h +11 -0
index 1bb6fb2f1523..b75941c811e6 100644
@@ -76,6 +76,12 @@ enum lsm_event {
 	LSM_POLICY_CHANGE,
 };
 
+enum lockdown_reason {
+	LOCKDOWN_NONE,
+	LOCKDOWN_INTEGRITY_MAX,
+	LOCKDOWN_CONFIDENTIALITY_MAX,
+};
+
 /* These functions are in security/commoncap.c */
 extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
 		       int cap, unsigned int opts);
@@ -389,6 +395,7 @@ void security_inode_invalidate_secctx(struct inode *inode);
 int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen);
 int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
 int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
+int security_is_locked_down(enum lockdown_reason what);
 #else /* CONFIG_SECURITY */
 
 static inline int call_lsm_notifier(enum lsm_event event, void *data)
@@ -1189,6 +1196,10 @@ static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32
 {
 	return -EOPNOTSUPP;
 }
+static inline int security_is_locked_down(enum lockdown_reason what)
+{
+	return 0;
+}
 #endif	/* CONFIG_SECURITY */
 
 #ifdef CONFIG_SECURITY_NETWORK
security/security.c +6 -0
index 2a6672c9e72f..17c17d4d8552 100644
@@ -2378,3 +2378,9 @@ void security_bpf_prog_free(struct bpf_prog_aux *aux)
 	call_void_hook(bpf_prog_free_security, aux);
 }
 #endif /* CONFIG_BPF_SYSCALL */
+
+int security_is_locked_down(enum lockdown_reason what)
+{
+	return call_int_hook(locked_down, 0, what);
+}
+EXPORT_SYMBOL(security_is_locked_down);
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#7 lore raw

Re: [PATCH V33 02/30] security: Add a "locked down" LSM hook

Quoted 49 lines · Matthew Garrett

Add a mechanism to allow LSMs to make a policy decision around whether kernel functionality that would allow tampering with or examining the runtime state of the kernel should be permitted.

---
 include/linux/lsm_hooks.h |  2 ++
 include/linux/security.h  | 11 +++++++++++
 security/security.c       |  6 ++++++
 3 files changed, 19 insertions(+)
include/linux/lsm_hooks.h +2 -0
index 66fd1eac7a32..df2aebc99838 100644
@@ -1790,6 +1790,7 @@ union security_list_options {
 	int (*bpf_prog_alloc_security)(struct bpf_prog_aux *aux);
 	void (*bpf_prog_free_security)(struct bpf_prog_aux *aux);
 #endif /* CONFIG_BPF_SYSCALL */
+	int (*locked_down)(enum lockdown_reason what);
 };
 
 struct security_hook_heads {
@@ -2027,6 +2028,7 @@ struct security_hook_heads {
 	struct hlist_head bpf_prog_alloc_security;
 	struct hlist_head bpf_prog_free_security;
 #endif /* CONFIG_BPF_SYSCALL */
+	struct hlist_head locked_down;
 } __randomize_layout;
 
 /*
include/linux/security.h +6 -0
index 1bb6fb2f1523..b75941c811e6 100644
@@ -76,6 +76,12 @@ enum lsm_event {
 	LSM_POLICY_CHANGE,
 };
 
+enum lockdown_reason {
+	LOCKDOWN_NONE,
+	LOCKDOWN_INTEGRITY_MAX,
+	LOCKDOWN_CONFIDENTIALITY_MAX,
+};
+
 /* These functions are in security/commoncap.c */
 extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
 		       int cap, unsigned int opts);

include/linux/security.h void security_inode_invalidate_secctx(struct inode *inode); · line 398

Quoted 4 lines
include/linux/security.h +1 -0
@@ -389,6 +395,7 @@ void security_inode_invalidate_secctx(struct inode *inode);
 int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen);
 int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
 int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
+int security_is_locked_down(enum lockdown_reason what);

bikeshed: can this just be called "security_locked_down" without the "is"?

-Kees

Quoted 31 lines
include/linux/security.h +4 -0
 #else /* CONFIG_SECURITY */
 
 static inline int call_lsm_notifier(enum lsm_event event, void *data)
@@ -1189,6 +1196,10 @@ static inline int security_inode_getsecctx(struct inode *inode, void **ctx, u32
 {
 	return -EOPNOTSUPP;
 }
+static inline int security_is_locked_down(enum lockdown_reason what)
+{
+	return 0;
+}
 #endif	/* CONFIG_SECURITY */
 
 #ifdef CONFIG_SECURITY_NETWORK
security/security.c +6 -0
index 2a6672c9e72f..17c17d4d8552 100644
@@ -2378,3 +2378,9 @@ void security_bpf_prog_free(struct bpf_prog_aux *aux)
 	call_void_hook(bpf_prog_free_security, aux);
 }
 #endif /* CONFIG_BPF_SYSCALL */
+
+int security_is_locked_down(enum lockdown_reason what)
+{
+	return call_int_hook(locked_down, 0, what);
+}
+EXPORT_SYMBOL(security_is_locked_down);
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
Signature · 1 line
Kees Cook
#8 lore raw

Re: [PATCH V33 02/30] security: Add a "locked down" LSM hook

Quoted 2 lines · Kees Cook

bikeshed: can this just be called "security_locked_down" without the "is"?

Sure.

#9 lore raw

PATCH v33 3/30 security: Add a static lockdown policy LSM

In reply to Matthew Garrett

While existing LSMs can be extended to handle lockdown policy, distributions generally want to be able to apply a straightforward static policy. This patch adds a simple LSM that can be configured to reject either integrity or all lockdown queries, and can be configured at runtime (through securityfs), boot time (via a kernel parameter) or build time (via a kconfig option). Based on initial code by David Howells.

---
 .../admin-guide/kernel-parameters.txt         |   9 +
 include/linux/security.h                      |   4 +
 security/Kconfig                              |   3 +-
 security/Makefile                             |   2 +
 security/lockdown/Kconfig                     |  46 +++++
 security/lockdown/Makefile                    |   1 +
 security/lockdown/lockdown.c                  | 168 ++++++++++++++++++
 7 files changed, 232 insertions(+), 1 deletion(-)
 create mode 100644 security/lockdown/Kconfig
 create mode 100644 security/lockdown/Makefile
 create mode 100644 security/lockdown/lockdown.c
Documentation/admin-guide/kernel-parameters.txt +9 -0
index 2b8ee90bb644..fa336f6cd5bc 100644
@@ -2239,6 +2239,15 @@
 	lockd.nlm_udpport=M	[NFS] Assign UDP port.
 			Format: <integer>
 
+	lockdown=	[SECURITY]
+			{ integrity | confidentiality }
+			Enable the kernel lockdown feature. If set to
+			integrity, kernel features that allow userland to
+			modify the running kernel are disabled. If set to
+			confidentiality, kernel features that allow userland
+			to extract confidential information from the kernel
+			are also disabled.
+
 	locktorture.nreaders_stress= [KNL]
 			Set the number of locking read-acquisition kthreads.
 			Defaults to being automatically set based on the
include/linux/security.h +4 -0
index b75941c811e6..a86a7739ca24 100644
@@ -76,6 +76,10 @@ enum lsm_event {
 	LSM_POLICY_CHANGE,
 };
 
+/*
+ *  If you add to this, remember to extend lockdown_reasons in
+ *  security/lockdown/lockdown.c.
+ */
 enum lockdown_reason {
 	LOCKDOWN_NONE,
 	LOCKDOWN_INTEGRITY_MAX,
security/Kconfig +2 -1
index 1d6463fb1450..c35aa72103df 100644
@@ -236,12 +236,13 @@ source "security/apparmor/Kconfig"
 source "security/loadpin/Kconfig"
 source "security/yama/Kconfig"
 source "security/safesetid/Kconfig"
+source "security/lockdown/Kconfig"
 
 source "security/integrity/Kconfig"
 
 config LSM
 	string "Ordered list of enabled LSMs"
-	default "yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
+	default "lockdown,yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
 	help
 	  A comma-separated list of LSMs, in initialization order.
 	  Any LSMs left off this list will be ignored. This can be
security/Makefile +2 -0
index c598b904938f..be1dd9d2cb2f 100644
@@ -11,6 +11,7 @@ subdir-$(CONFIG_SECURITY_APPARMOR)	+= apparmor
 subdir-$(CONFIG_SECURITY_YAMA)		+= yama
 subdir-$(CONFIG_SECURITY_LOADPIN)	+= loadpin
 subdir-$(CONFIG_SECURITY_SAFESETID)    += safesetid
+subdir-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown
 
 # always enable default capabilities
 obj-y					+= commoncap.o
@@ -27,6 +28,7 @@ obj-$(CONFIG_SECURITY_APPARMOR)		+= apparmor/
 obj-$(CONFIG_SECURITY_YAMA)		+= yama/
 obj-$(CONFIG_SECURITY_LOADPIN)		+= loadpin/
 obj-$(CONFIG_SECURITY_SAFESETID)       += safesetid/
+obj-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown/
 obj-$(CONFIG_CGROUP_DEVICE)		+= device_cgroup.o
 
 # Object integrity file lists
security/lockdown/Kconfig new file +46 -0

46 lines not on this page · raw message

security/lockdown/Makefile new file +1 -0
new file mode 100644
index 000000000000..e3634b9017e7
@@ -0,0 +1 @@
+obj-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown.o
security/lockdown/lockdown.c new file +168 -0

168 lines not on this page · raw message

Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#10 lore raw

Re: [PATCH V33 03/30] security: Add a static lockdown policy LSM

Quoted 48 lines · Matthew Garrett

While existing LSMs can be extended to handle lockdown policy, distributions generally want to be able to apply a straightforward static policy. This patch adds a simple LSM that can be configured to reject either integrity or all lockdown queries, and can be configured at runtime (through securityfs), boot time (via a kernel parameter) or build time (via a kconfig option). Based on initial code by David Howells.

---
 .../admin-guide/kernel-parameters.txt         |   9 +
 include/linux/security.h                      |   4 +
 security/Kconfig                              |   3 +-
 security/Makefile                             |   2 +
 security/lockdown/Kconfig                     |  46 +++++
 security/lockdown/Makefile                    |   1 +
 security/lockdown/lockdown.c                  | 168 ++++++++++++++++++
 7 files changed, 232 insertions(+), 1 deletion(-)
 create mode 100644 security/lockdown/Kconfig
 create mode 100644 security/lockdown/Makefile
 create mode 100644 security/lockdown/lockdown.c
Documentation/admin-guide/kernel-parameters.txt +9 -0
index 2b8ee90bb644..fa336f6cd5bc 100644
@@ -2239,6 +2239,15 @@
 	lockd.nlm_udpport=M	[NFS] Assign UDP port.
 			Format: <integer>
 
+	lockdown=	[SECURITY]
+			{ integrity | confidentiality }
+			Enable the kernel lockdown feature. If set to
+			integrity, kernel features that allow userland to
+			modify the running kernel are disabled. If set to
+			confidentiality, kernel features that allow userland
+			to extract confidential information from the kernel
+			are also disabled.
+
 	locktorture.nreaders_stress= [KNL]
 			Set the number of locking read-acquisition kthreads.
 			Defaults to being automatically set based on the
include/linux/security.h +0 -0
index b75941c811e6..a86a7739ca24 100644

include/linux/security.h enum lsm_event { · line 82

Quoted 7 lines
include/linux/security.h +4 -0
@@ -76,6 +76,10 @@ enum lsm_event {
 	LSM_POLICY_CHANGE,
 };
 
+/*
+ *  If you add to this, remember to extend lockdown_reasons in
+ *  security/lockdown/lockdown.c.
+ */

Best to add something like:

BUILD_BUG_ON(ARRAY_SIZE(lockdown_reasons), LOCKDOWN_CONFIDENTIALLY_MAX);

to actually enforce this.

Quoted 9 lines
include/linux/security.h +0 -0
 enum lockdown_reason {
 	LOCKDOWN_NONE,
 	LOCKDOWN_INTEGRITY_MAX,
security/Kconfig +0 -0
index 1d6463fb1450..c35aa72103df 100644
@@ -236,12 +236,13 @@ source "security/apparmor/Kconfig"
 source "security/loadpin/Kconfig"

security/Kconfig source "security/apparmor/Kconfig" · line 245

Quoted 10 lines
security/Kconfig +2 -1
 source "security/yama/Kconfig"
 source "security/safesetid/Kconfig"
+source "security/lockdown/Kconfig"
 
 source "security/integrity/Kconfig"
 
 config LSM
 	string "Ordered list of enabled LSMs"
-	default "yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
+	default "lockdown,yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"

Is this needed? It seems like the early LSMs are totally ignored for ordering?

Quoted 29 lines
security/Kconfig +0 -0
 	help
 	  A comma-separated list of LSMs, in initialization order.
 	  Any LSMs left off this list will be ignored. This can be
security/Makefile +2 -0
index c598b904938f..be1dd9d2cb2f 100644
@@ -11,6 +11,7 @@ subdir-$(CONFIG_SECURITY_APPARMOR)	+= apparmor
 subdir-$(CONFIG_SECURITY_YAMA)		+= yama
 subdir-$(CONFIG_SECURITY_LOADPIN)	+= loadpin
 subdir-$(CONFIG_SECURITY_SAFESETID)    += safesetid
+subdir-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown
 
 # always enable default capabilities
 obj-y					+= commoncap.o
@@ -27,6 +28,7 @@ obj-$(CONFIG_SECURITY_APPARMOR)		+= apparmor/
 obj-$(CONFIG_SECURITY_YAMA)		+= yama/
 obj-$(CONFIG_SECURITY_LOADPIN)		+= loadpin/
 obj-$(CONFIG_SECURITY_SAFESETID)       += safesetid/
+obj-$(CONFIG_SECURITY_LOCKDOWN_LSM)	+= lockdown/
 obj-$(CONFIG_CGROUP_DEVICE)		+= device_cgroup.o
 
 # Object integrity file lists
security/lockdown/Kconfig new file +0 -0
new file mode 100644
index 000000000000..431cd2b9a14e

security/lockdown/Kconfig line 9

Quoted 9 lines
security/lockdown/Kconfig new file +9 -0
@@ -0,0 +1,46 @@
+config SECURITY_LOCKDOWN_LSM
+	bool "Basic module for enforcing kernel lockdown"
+	depends on SECURITY
+	help
+	  Build support for an LSM that enforces a coarse kernel lockdown
+	  behaviour.
+
+config SECURITY_LOCKDOWN_LSM_EARLY
+        bool "Enable lockdown LSM early in init"

whitespace glitches?

Quoted 57 lines
security/lockdown/Kconfig new file +37 -0
+	depends on SECURITY_LOCKDOWN_LSM
+	help
+	  Enable the lockdown LSM early in boot. This is necessary in order
+	  to ensure that lockdown enforcement can be carried out on kernel
+	  boot parameters that are otherwise parsed before the security
+	  subsystem is fully initialised.
+
+choice
+	prompt "Kernel default lockdown mode"
+	default LOCK_DOWN_KERNEL_FORCE_NONE
+	depends on SECURITY_LOCKDOWN_LSM
+	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
+
security/lockdown/Makefile new file +1 -0
new file mode 100644
index 000000000000..e3634b9017e7
@@ -0,0 +1 @@
+obj-$(CONFIG_SECURITY_LOCKDOWN_LSM) += lockdown.o
security/lockdown/lockdown.c new file +7 -0
new file mode 100644
index 000000000000..1ecb2eecb245
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Lock down the kernel
+ *
+ * Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells ([email protected])
+ *
+ * This program is free software; you can redistribute it and/or

security/lockdown/lockdown.c line 17

Quoted 10 lines
security/lockdown/lockdown.c new file +10 -0
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#include <linux/security.h>
+#include <linux/export.h>
+#include <linux/lsm_hooks.h>
+
+static enum lockdown_reason kernel_locked_down;

What's the use-case for runtime changing this value? (If you didn't, you could make it __ro_after_init.)

Quoted 78 lines
security/lockdown/lockdown.c new file +78 -0
+
+static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
+	[LOCKDOWN_NONE] = "none",
+	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
+	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
+};
+
+static enum lockdown_reason lockdown_levels[] = {LOCKDOWN_NONE,
+						 LOCKDOWN_INTEGRITY_MAX,
+						 LOCKDOWN_CONFIDENTIALITY_MAX};
+
+/*
+ * Put the kernel into lock-down mode.
+ */
+static int lock_kernel_down(const char *where, enum lockdown_reason level)
+{
+	if (kernel_locked_down >= level)
+		return -EPERM;
+
+	kernel_locked_down = level;
+	pr_notice("Kernel is locked down from %s; see man kernel_lockdown.7\n",
+		  where);
+	return 0;
+}
+
+static int __init lockdown_param(char *level)
+{
+	if (!level)
+		return -EINVAL;
+
+	if (strcmp(level, "integrity") == 0)
+		lock_kernel_down("command line", LOCKDOWN_INTEGRITY_MAX);
+	else if (strcmp(level, "confidentiality") == 0)
+		lock_kernel_down("command line", LOCKDOWN_CONFIDENTIALITY_MAX);
+	else
+		return -EINVAL;
+
+	return 0;
+}
+
+early_param("lockdown", lockdown_param);
+
+/**
+ * lockdown_is_locked_down - Find out if the kernel is locked down
+ * @what: Tag to use in notice generated if lockdown is in effect
+ */
+static int lockdown_is_locked_down(enum lockdown_reason what)
+{	
+	if ((kernel_locked_down >= what) && lockdown_reasons[what])
+		pr_notice("Lockdown: %s is restricted; see man kernel_lockdown.7\n",
+			  lockdown_reasons[what]);
+	return (kernel_locked_down >= what);
+}
+
+static struct security_hook_list lockdown_hooks[] __lsm_ro_after_init = {
+	LSM_HOOK_INIT(locked_down, lockdown_is_locked_down),
+};
+
+static int __init lockdown_lsm_init(void)
+{
+#if defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_INTEGRITY)
+	lock_kernel_down("Kernel configuration", LOCKDOWN_INTEGRITY_MAX);
+#elif defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_CONFIDENTIALITY)
+	lock_kernel_down("Kernel configuration", LOCKDOWN_CONFIDENTIALITY_MAX);
+#endif
+	security_add_hooks(lockdown_hooks, ARRAY_SIZE(lockdown_hooks),
+			   "lockdown");
+	return 0;
+}
+
+static ssize_t lockdown_read(struct file *filp, char __user *buf, size_t count,
+			     loff_t *ppos)
+{
+	char temp[80];
+	int i, offset=0;
+
+	for (i = 0; i < ARRAY_SIZE(lockdown_levels); i++) {
+		enum lockdown_reason level = lockdown_levels[i];

security/lockdown/lockdown.c line 105

Quoted 10 lines
security/lockdown/lockdown.c new file +10 -0
+
+		if (lockdown_reasons[level]) {
+			const char *label = lockdown_reasons[level];
+
+			if (kernel_locked_down == level)
+				offset += sprintf(temp+offset, "[%s] ", label);
+			else
+				offset += sprintf(temp+offset, "%s ", label);
+		}
+	}

I thought there were helpers for this kind of thing?

Quoted 50 lines
security/lockdown/lockdown.c new file +50 -0
+
+	/* Convert the last space to a newline if needed. */
+	if (offset > 0)
+		temp[offset-1] = '\n';
+
+	return simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
+}
+
+static ssize_t lockdown_write(struct file *file, const char __user *buf,
+			      size_t n, loff_t *ppos)
+{
+	char *state;
+	int i, len, err = -EINVAL;
+
+	state = memdup_user_nul(buf, n);
+	if (IS_ERR(state))
+		return PTR_ERR(state);
+
+	len = strlen(state);
+	if (len && state[len-1] == '\n') {
+		state[len-1] = '\0';
+		len--;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(lockdown_levels); i++) {
+		enum lockdown_reason level = lockdown_levels[i];
+		const char *label = lockdown_reasons[level];
+
+		if (label && !strcmp(state, label))
+			err = lock_kernel_down("securityfs", level);
+	}
+
+	kfree(state);
+	return err ? err : n;
+}
+
+static const struct file_operations lockdown_ops = {
+	.read  = lockdown_read,
+	.write = lockdown_write,
+};
+
+static int __init lockdown_secfs_init(void)
+{
+	struct dentry *dentry;
+
+	dentry = securityfs_create_file("lockdown", 0600, NULL, NULL,
+					&lockdown_ops);
+	if (IS_ERR(dentry))
+		return PTR_ERR(dentry);
+

security/lockdown/lockdown.c line 165

Quoted 10 lines
security/lockdown/lockdown.c new file +10 -0
+	return 0;
+}
+
+core_initcall(lockdown_secfs_init);
+
+#ifdef CONFIG_SECURITY_LOCKDOWN_LSM_EARLY
+DEFINE_EARLY_LSM(lockdown) = {
+#else
+DEFINE_LSM(lockdown) = {
+#endif

Ah, I see now: it *might* be an early LSM. What states are missed if not early? Only parameters? I think the behavior differences need to be spelled out in Kconfig (or somewhere...)

Quoted 6 lines
security/lockdown/lockdown.c new file +3 -0
+	.name = "lockdown",
+	.init = lockdown_lsm_init,
+};
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
Signature · 1 line
Kees Cook
#11 lore raw

Re: [PATCH V33 03/30] security: Add a static lockdown policy LSM

Quoted 7 lines · Kees Cook
Quoted 4 lines · Matthew Garrett

+/*
+ * If you add to this, remember to extend lockdown_reasons in
+ * security/lockdown/lockdown.c.
+ */

Quoted 5 lines

Best to add something like:

BUILD_BUG_ON(ARRAY_SIZE(lockdown_reasons), LOCKDOWN_CONFIDENTIALLY_MAX);

to actually enforce this.

I don't think this will work - it'll only catch cases where someone adds a new enum after LOCKDOWN_CONFIDENTIALITY_MAX.

Quoted 15 lines
Quoted 15 lines

enum lockdown_reason {
LOCKDOWN_NONE,
LOCKDOWN_INTEGRITY_MAX,

security/Kconfig +1 -0
index 1d6463fb1450..c35aa72103df 100644
@@ -236,12 +236,13 @@ source "security/apparmor/Kconfig"
 source "security/loadpin/Kconfig"
 source "security/yama/Kconfig"
 source "security/safesetid/Kconfig"
+source "security/lockdown/Kconfig"
 
 source "security/integrity/Kconfig"
 
Quoted 7 lines

security/Kconfig source "security/apparmor/Kconfig" · line 245

Quoted 4 lines
security/Kconfig +1 -1
 config LSM
      string "Ordered list of enabled LSMs"
-     default "yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"
+     default "lockdown,yama,loadpin,safesetid,integrity,selinux,smack,tomoyo,apparmor"

Is this needed? It seems like the early LSMs are totally ignored for ordering?

It's relevant if it's not configured as an early LSM.

Quoted 11 lines

security/Kconfig source "security/apparmor/Kconfig"

Quoted 9 lines
security/Kconfig +9 -0
+config SECURITY_LOCKDOWN_LSM
+     bool "Basic module for enforcing kernel lockdown"
+     depends on SECURITY
+     help
+       Build support for an LSM that enforces a coarse kernel lockdown
+       behaviour.
+
+config SECURITY_LOCKDOWN_LSM_EARLY
+        bool "Enable lockdown LSM early in init"

whitespace glitches?

Fxied.

Quoted 4 lines
Quoted 1 line

+static enum lockdown_reason kernel_locked_down;

What's the use-case for runtime changing this value? (If you didn't, you could make it __ro_after_init.)

Cases where the admin wants to make the policy more strict after boot via securityfs.

Quoted 6 lines
Quoted 6 lines
security/Kconfig +6 -0
+     for (i = 0; i < ARRAY_SIZE(lockdown_levels); i++) {
+             enum lockdown_reason level = lockdown_levels[i];
+
+             if (lockdown_reasons[level]) {
+                     const char *label = lockdown_reasons[level];
+
Quoted 8 lines

security/Kconfig

Quoted 6 lines
security/Kconfig +6 -0
+                     if (kernel_locked_down == level)
+                             offset += sprintf(temp+offset, "[%s] ", label);
+                     else
+                             offset += sprintf(temp+offset, "%s ", label);
+             }
+     }

I thought there were helpers for this kind of thing?

I'll check, I'm bad at finding these new fangled things.

Quoted 3 lines

Ah, I see now: it *might* be an early LSM. What states are missed if not early? Only parameters? I think the behavior differences need to be spelled out in Kconfig (or somewhere...)

Ok.

#12 lore raw

Re: [PATCH V33 03/30] security: Add a static lockdown policy LSM

Quoted 1 line · Matthew Garrett

I'll check, I'm bad at finding these new fangled things.

Ah, I see - there's sysfs_match_string(), but that doesn't really work for this case because we'd still need to do another set of checks to see whether the level we get is in lockdown_levels, not just lockdown_reasons.

maintainer
#13 lore raw

Re: [PATCH V33 03/30] security: Add a static lockdown policy LSM

In reply to Matthew Garrett
Quoted 5 lines · Matthew Garrett
Documentation/admin-guide/kernel-parameters.txt +0 -0
@@ -2239,6 +2239,15 @@
 	lockd.nlm_udpport=M	[NFS] Assign UDP port.
 			Format: <integer>

Documentation/admin-guide/kernel-parameters.txt line 2250

Quoted 10 lines
Documentation/admin-guide/kernel-parameters.txt +9 -0
 
+	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.
+

Does "also" imply "integrity" is a prereq for "confidentiality"?

Quoted 40 lines
security/lockdown/Kconfig new file +34 -0
new file mode 100644
index 000000000000..431cd2b9a14e
@@ -0,0 +1,46 @@
+config SECURITY_LOCKDOWN_LSM
+	bool "Basic module for enforcing kernel lockdown"
+	depends on SECURITY
+	help
+	  Build support for an LSM that enforces a coarse kernel lockdown
+	  behaviour.
+
+config SECURITY_LOCKDOWN_LSM_EARLY
+        bool "Enable lockdown LSM early in init"
+	depends on SECURITY_LOCKDOWN_LSM
+	help
+	  Enable the lockdown LSM early in boot. This is necessary in order
+	  to ensure that lockdown enforcement can be carried out on kernel
+	  boot parameters that are otherwise parsed before the security
+	  subsystem is fully initialised.
+
+choice
+	prompt "Kernel default lockdown mode"
+	default LOCK_DOWN_KERNEL_FORCE_NONE
+	depends on SECURITY_LOCKDOWN_LSM
+	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

security/lockdown/Kconfig line 44

Quoted 10 lines
security/lockdown/Kconfig new file +10 -0
+	 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.
+

Is there a missing dependency on LOCK_DOWN_KERNEL_FORCE_INTEGRITY here?

Quoted 12 lines
security/lockdown/Kconfig new file +2 -0
+endchoice
+
security/lockdown/lockdown.c new file +2 -0
new file mode 100644
index 000000000000..1ecb2eecb245
 
+
+static int __init lockdown_lsm_init(void)

security/lockdown/lockdown.c line 86

Quoted 10 lines
security/lockdown/lockdown.c new file +10 -0
+{
+#if defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_INTEGRITY)
+	lock_kernel_down("Kernel configuration", LOCKDOWN_INTEGRITY_MAX);
+#elif defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_CONFIDENTIALITY)
+	lock_kernel_down("Kernel configuration", LOCKDOWN_CONFIDENTIALITY_MAX);
+#endif
+	security_add_hooks(lockdown_hooks, ARRAY_SIZE(lockdown_hooks),
+			   "lockdown");
+	return 0;
+}

If there is a dependency on "defined(CONFIG_LOCK_DOWN_KERNEL_FORCE_INTEGRITY" for "CONFIG_LOCK_DOWN_KERNEL_FORCE_CONFIDENTIALITY", then the ordering should be reversed.  If there isn't a dependency of one on the other, then replace the "elif" with "endif".

Mimi

#14 lore raw

PATCH v33 4/30 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.]

---
 include/linux/security.h     |  1 +
 kernel/module.c              | 39 +++++++++++++++++++++++++++++-------
 security/lockdown/lockdown.c |  1 +
 3 files changed, 34 insertions(+), 7 deletions(-)
include/linux/security.h +1 -0
index a86a7739ca24..a7612b03b42a 100644
@@ -82,6 +82,7 @@ enum lsm_event {
  */
 enum lockdown_reason {
 	LOCKDOWN_NONE,
+	LOCKDOWN_MODULE_SIGNATURE,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
kernel/module.c +32 -7
index 0b9aa8ab89f0..780e9605ff88 100644
@@ -2763,8 +2763,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;
 
 	/*
@@ -2779,16 +2780,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 (security_is_locked_down(LOCKDOWN_MODULE_SIGNATURE))
+			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)
security/lockdown/lockdown.c +1 -0
index 1ecb2eecb245..08abd7e6609b 100644
@@ -18,6 +18,7 @@ static enum lockdown_reason kernel_locked_down;
 
 static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_NONE] = "none",
+	[LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#15 lore raw

Re: [PATCH V33 04/30] Enforce module signatures if the kernel is locked down

Quoted 88 lines · 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.]

---
 include/linux/security.h     |  1 +
 kernel/module.c              | 39 +++++++++++++++++++++++++++++-------
 security/lockdown/lockdown.c |  1 +
 3 files changed, 34 insertions(+), 7 deletions(-)
include/linux/security.h +1 -0
index a86a7739ca24..a7612b03b42a 100644
@@ -82,6 +82,7 @@ enum lsm_event {
  */
 enum lockdown_reason {
 	LOCKDOWN_NONE,
+	LOCKDOWN_MODULE_SIGNATURE,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
kernel/module.c +15 -6
index 0b9aa8ab89f0..780e9605ff88 100644
@@ -2763,8 +2763,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;
 
 	/*
@@ -2779,16 +2780,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:

kernel/module.c static int module_sig_check(struct load_info *info, int flags) · line 2807

Quoted 10 lines
kernel/module.c +8 -1
+		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 (security_is_locked_down(LOCKDOWN_MODULE_SIGNATURE))
+			return -EPERM;

LSM hooks should return the desired error code. Here and in all the other patches, I'd expect to see stuff like:

	ret = security_locked_down(LOCKDOWN_MODULE_SIGNATURE);
	if (ret)
		return ret;
Quoted 27 lines
kernel/module.c +9 -0
+		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)
security/lockdown/lockdown.c +1 -0
index 1ecb2eecb245..08abd7e6609b 100644
@@ -18,6 +18,7 @@ static enum lockdown_reason kernel_locked_down;
 
 static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_NONE] = "none",
+	[LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
Signature · 1 line
Kees Cook
#16 lore raw

PATCH v33 5/30 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           | 4 +++-
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 5 insertions(+), 1 deletion(-)
drivers/char/mem.c +3 -1
index b08dc50f9f26..1ee6cff43eea 100644
@@ -29,8 +29,8 @@
 #include <linux/export.h>
 #include <linux/io.h>
 #include <linux/uio.h>
-
 #include <linux/uaccess.h>
+#include <linux/security.h>
 
 #ifdef CONFIG_IA64
 # include <linux/efi.h>
@@ -786,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 (security_is_locked_down(LOCKDOWN_DEV_MEM))
+		return -EPERM;
 	return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
 }
 
include/linux/security.h +1 -0
index a7612b03b42a..034a8d54687f 100644
@@ -83,6 +83,7 @@ enum lsm_event {
 enum lockdown_reason {
 	LOCKDOWN_NONE,
 	LOCKDOWN_MODULE_SIGNATURE,
+	LOCKDOWN_DEV_MEM,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index 08abd7e6609b..43a049b3b66a 100644
@@ -19,6 +19,7 @@ static enum lockdown_reason kernel_locked_down;
 static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_NONE] = "none",
 	[LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
+	[LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#17 lore raw

PATCH v33 6/30 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.

---
 include/linux/security.h     | 1 +
 kernel/kexec.c               | 7 +++++++
 security/lockdown/lockdown.c | 1 +
 3 files changed, 9 insertions(+)
include/linux/security.h +1 -0
index 034a8d54687f..2d3c69b9fd04 100644
@@ -84,6 +84,7 @@ enum lockdown_reason {
 	LOCKDOWN_NONE,
 	LOCKDOWN_MODULE_SIGNATURE,
 	LOCKDOWN_DEV_MEM,
+	LOCKDOWN_KEXEC,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
kernel/kexec.c +7 -0
index 68559808fdfa..040819d7b11b 100644
@@ -207,6 +207,13 @@ static inline int kexec_load_check(unsigned long nr_segments,
 	if (result < 0)
 		return result;
 
+	/*
+	 * kexec can be used to circumvent module loading restrictions, so
+	 * prevent loading in that case
+	 */
+	if (security_is_locked_down(LOCKDOWN_KEXEC))
+		return -EPERM;
+
 	/*
 	 * Verify we have a legal set of flags
 	 * This leaves us room for future extensions.
security/lockdown/lockdown.c +1 -0
index 43a049b3b66a..94af1c3583d8 100644
@@ -20,6 +20,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_NONE] = "none",
 	[LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
 	[LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port",
+	[LOCKDOWN_KEXEC] = "kexec of unsigned images",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#18 lore raw

PATCH v33 7/30 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 22f60dd26460..4243359ac509 100644
@@ -182,6 +182,7 @@ setup_efi_state(struct boot_params *params, unsigned long params_load_addr,
 	if (efi_enabled(EFI_OLD_MEMMAP))
 		return 0;
 
+	params->secure_boot = boot_params.secure_boot;
 	ei->efi_loader_signature = current_ei->efi_loader_signature;
 	ei->efi_systab = current_ei->efi_systab;
 	ei->efi_systab_hi = current_ei->efi_systab_hi;
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#19 lore raw

PATCH v33 8/30 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 c1f9b3cf437c..84381dd60760 100644
@@ -2012,20 +2012,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.22.0.410.gd8fdbe21b5-goog
#20 lore raw

PATCH v33 9/30 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..455f4fc794f3 100644
@@ -239,6 +239,12 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd,
 		}
 
 		ret = 0;
+
+		if (security_is_locked_down(LOCKDOWN_KEXEC)) {
+			ret = -EPERM;
+			goto out;
+		}
+
 		break;
 
 		/* All other errors are fatal, including nomem, unparseable
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#21 lore raw

PATCH v33 10/30 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.

---
 include/linux/security.h     | 1 +
 kernel/power/hibernate.c     | 4 +++-
 security/lockdown/lockdown.c | 1 +
 3 files changed, 5 insertions(+), 1 deletion(-)
include/linux/security.h +1 -0
index 2d3c69b9fd04..deac722f0d86 100644
@@ -85,6 +85,7 @@ enum lockdown_reason {
 	LOCKDOWN_MODULE_SIGNATURE,
 	LOCKDOWN_DEV_MEM,
 	LOCKDOWN_KEXEC,
+	LOCKDOWN_HIBERNATION,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
kernel/power/hibernate.c +3 -1
index abef759de7c8..5804ffeb8622 100644
@@ -32,6 +32,7 @@
 #include <linux/ctype.h>
 #include <linux/genhd.h>
 #include <linux/ktime.h>
+#include <linux/security.h>
 #include <trace/events/power.h>
 
 #include "power.h"
@@ -70,7 +71,8 @@ static const struct platform_hibernation_ops *hibernation_ops;
 
 bool hibernation_available(void)
 {
-	return (nohibernate == 0);
+	return nohibernate == 0 &&
+		!security_is_locked_down(LOCKDOWN_HIBERNATION);
 }
 
 /**
security/lockdown/lockdown.c +1 -0
index 94af1c3583d8..42b7bc467ef6 100644
@@ -21,6 +21,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_MODULE_SIGNATURE] = "unsigned module loading",
 	[LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port",
 	[LOCKDOWN_KEXEC] = "kexec of unsigned images",
+	[LOCKDOWN_HIBERNATION] = "hibernation",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#22 lore raw

PATCH v33 11/30 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 | 4 ++++
 1 file changed, 4 insertions(+)
kernel/power/user.c +4 -0
index 2d8b60a3c86b..8a8d7f1c8fbb 100644
@@ -24,6 +24,7 @@
 #include <linux/console.h>
 #include <linux/cpu.h>
 #include <linux/freezer.h>
+#include <linux/security.h>
 
 #include <linux/uaccess.h>
 
@@ -52,6 +53,9 @@ static int snapshot_open(struct inode *inode, struct file *filp)
 	if (!hibernation_available())
 		return -EPERM;
 
+	if (security_is_locked_down(LOCKDOWN_HIBERNATION))
+		return -EPERM;
+
 	lock_system_sleep();
 
 	if (!atomic_add_unless(&snapshot_device_available, -1, 0)) {
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#23 lore raw

PATCH v33 12/30 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           | 10 +++++++++-
 drivers/pci/syscall.c        |  4 +++-
 include/linux/security.h     |  1 +
 security/lockdown/lockdown.c |  1 +
 5 files changed, 23 insertions(+), 2 deletions(-)
drivers/pci/pci-sysfs.c +9 -0
index 25794c27c7a4..00625267a5e4 100644
@@ -904,6 +904,9 @@ static ssize_t pci_write_config(struct file *filp, struct kobject *kobj,
 	loff_t init_off = off;
 	u8 *data = (u8 *) buf;
 
+	if (security_is_locked_down(LOCKDOWN_PCI_ACCESS))
+		return -EPERM;
+
 	if (off > dev->cfg_size)
 		return 0;
 	if (off + count > dev->cfg_size) {
@@ -1166,6 +1169,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 (security_is_locked_down(LOCKDOWN_PCI_ACCESS))
+		return -EPERM;
+
 	if (res->flags & IORESOURCE_MEM && iomem_is_exclusive(res->start))
 		return -EINVAL;
 
@@ -1241,6 +1247,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 (security_is_locked_down(LOCKDOWN_PCI_ACCESS))
+		return -EPERM;
+
 	return pci_resource_io(filp, kobj, attr, buf, off, count, true);
 }
 
drivers/pci/proc.c +9 -1
index 6fa1627ce08d..56e438bbefa4 100644
@@ -13,6 +13,7 @@
 #include <linux/seq_file.h>
 #include <linux/capability.h>
 #include <linux/uaccess.h>
+#include <linux/security.h>
 #include <asm/byteorder.h>
 #include "pci.h"
 
@@ -117,6 +118,9 @@ static ssize_t proc_bus_pci_write(struct file *file, const char __user *buf,
 	int size = dev->cfg_size;
 	int cnt;
 
+	if (security_is_locked_down(LOCKDOWN_PCI_ACCESS))
+		return -EPERM;
+
 	if (pos >= size)
 		return 0;
 	if (nbytes >= size)
@@ -196,6 +200,9 @@ static long proc_bus_pci_ioctl(struct file *file, unsigned int cmd,
 #endif /* HAVE_PCI_MMAP */
 	int ret = 0;
 
+	if (security_is_locked_down(LOCKDOWN_PCI_ACCESS))
+		return -EPERM;
+
 	switch (cmd) {
 	case PCIIOC_CONTROLLER:
 		ret = pci_domain_nr(dev->bus);
@@ -237,7 +244,8 @@ static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
 	struct pci_filp_private *fpriv = file->private_data;
 	int i, ret, write_combine = 0, res_bit = IORESOURCE_MEM;
 
-	if (!capable(CAP_SYS_RAWIO))
+	if (!capable(CAP_SYS_RAWIO) ||
+	    security_is_locked_down(LOCKDOWN_PCI_ACCESS))
 		return -EPERM;
 
 	if (fpriv->mmap_state == pci_mmap_io) {
drivers/pci/syscall.c +3 -1
index d96626c614f5..54f0a7721104 100644
@@ -7,6 +7,7 @@
 
 #include <linux/errno.h>
 #include <linux/pci.h>
+#include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/uaccess.h>
 #include "pci.h"
@@ -90,7 +91,8 @@ SYSCALL_DEFINE5(pciconfig_write, unsigned long, bus, unsigned long, dfn,
 	u32 dword;
 	int err = 0;
 
-	if (!capable(CAP_SYS_ADMIN))
+	if (!capable(CAP_SYS_ADMIN) ||
+	    security_is_locked_down(LOCKDOWN_PCI_ACCESS))
 		return -EPERM;
 
 	dev = pci_get_domain_bus_and_slot(0, bus, dfn);
include/linux/security.h +1 -0
index deac722f0d86..95aa5ac1fa6b 100644
@@ -86,6 +86,7 @@ enum lockdown_reason {
 	LOCKDOWN_DEV_MEM,
 	LOCKDOWN_KEXEC,
 	LOCKDOWN_HIBERNATION,
+	LOCKDOWN_PCI_ACCESS,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index 42b7bc467ef6..ae76a7cce7ba 100644
@@ -22,6 +22,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_DEV_MEM] = "/dev/mem,kmem,port",
 	[LOCKDOWN_KEXEC] = "kexec of unsigned images",
 	[LOCKDOWN_HIBERNATION] = "hibernation",
+	[LOCKDOWN_PCI_ACCESS] = "direct PCI access",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#24 lore raw

PATCH v33 13/30 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     | 7 +++++--
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 7 insertions(+), 2 deletions(-)
arch/x86/kernel/ioport.c +5 -2
index 0fe1c8782208..ac0ba0b2f3be 100644
@@ -11,6 +11,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/ioport.h>
+#include <linux/security.h>
 #include <linux/smp.h>
 #include <linux/stddef.h>
 #include <linux/slab.h>
@@ -31,7 +32,8 @@ long ksys_ioperm(unsigned long from, unsigned long num, int turn_on)
 
 	if ((from + num <= from) || (from + num > IO_BITMAP_BITS))
 		return -EINVAL;
-	if (turn_on && !capable(CAP_SYS_RAWIO))
+	if (turn_on && (!capable(CAP_SYS_RAWIO) ||
+			security_is_locked_down(LOCKDOWN_IOPORT)))
 		return -EPERM;
 
 	/*
@@ -126,7 +128,8 @@ SYSCALL_DEFINE1(iopl, unsigned int, level)
 		return -EINVAL;
 	/* Trying to gain more privileges? */
 	if (level > old) {
-		if (!capable(CAP_SYS_RAWIO))
+		if (!capable(CAP_SYS_RAWIO) ||
+		    security_is_locked_down(LOCKDOWN_IOPORT))
 			return -EPERM;
 	}
 	regs->flags = (regs->flags & ~X86_EFLAGS_IOPL) |
include/linux/security.h +1 -0
index 95aa5ac1fa6b..59f0ac7adfa6 100644
@@ -87,6 +87,7 @@ enum lockdown_reason {
 	LOCKDOWN_KEXEC,
 	LOCKDOWN_HIBERNATION,
 	LOCKDOWN_PCI_ACCESS,
+	LOCKDOWN_IOPORT,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index ae76a7cce7ba..6e426887bb23 100644
@@ -23,6 +23,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_KEXEC] = "kexec of unsigned images",
 	[LOCKDOWN_HIBERNATION] = "hibernation",
 	[LOCKDOWN_PCI_ACCESS] = "direct PCI access",
+	[LOCKDOWN_IOPORT] = "raw io port access",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#25 lore raw

PATCH v33 14/30 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 ++++++++
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 10 insertions(+)
arch/x86/kernel/msr.c +8 -0
index 4588414e2561..72f0ed5a93c3 100644
@@ -39,6 +39,7 @@
 #include <linux/notifier.h>
 #include <linux/uaccess.h>
 #include <linux/gfp.h>
+#include <linux/security.h>
 
 #include <asm/cpufeature.h>
 #include <asm/msr.h>
@@ -84,6 +85,9 @@ static ssize_t msr_write(struct file *file, const char __user *buf,
 	int err = 0;
 	ssize_t bytes = 0;
 
+	if (security_is_locked_down(LOCKDOWN_MSR))
+		return -EPERM;
+
 	if (count % 8)
 		return -EINVAL;	/* Invalid chunk size */
 
@@ -135,6 +139,10 @@ static long msr_ioctl(struct file *file, unsigned int ioc, unsigned long arg)
 			err = -EFAULT;
 			break;
 		}
+		if (security_is_locked_down(LOCKDOWN_MSR)) {
+			err = -EPERM;
+			break;
+		}
 		err = wrmsr_safe_regs_on_cpu(cpu, regs);
 		if (err)
 			break;
include/linux/security.h +1 -0
index 59f0ac7adfa6..81c0968e485f 100644
@@ -88,6 +88,7 @@ enum lockdown_reason {
 	LOCKDOWN_HIBERNATION,
 	LOCKDOWN_PCI_ACCESS,
 	LOCKDOWN_IOPORT,
+	LOCKDOWN_MSR,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index 6e426887bb23..a01301972290 100644
@@ -24,6 +24,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_HIBERNATION] = "hibernation",
 	[LOCKDOWN_PCI_ACCESS] = "direct PCI access",
 	[LOCKDOWN_IOPORT] = "raw io port access",
+	[LOCKDOWN_MSR] = "raw MSR access",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#26 lore raw

PATCH v33 15/30 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 | 4 ++++
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 6 insertions(+)
drivers/acpi/custom_method.c +4 -0
index aa972dc5cb7e..5c684b09a2d1 100644
@@ -8,6 +8,7 @@
 #include <linux/uaccess.h>
 #include <linux/debugfs.h>
 #include <linux/acpi.h>
+#include <linux/security.h>
 
 #include "internal.h"
 
@@ -29,6 +30,9 @@ static ssize_t cm_write(struct file *file, const char __user * user_buf,
 	struct acpi_table_header table;
 	acpi_status status;
 
+	if (security_is_locked_down(LOCKDOWN_ACPI_TABLES))
+		return -EPERM;
+
 	if (!(*ppos)) {
 		/* parse the table header to get the table length */
 		if (count <= sizeof(struct acpi_table_header))
include/linux/security.h +1 -0
index 81c0968e485f..88d0f5d0cd87 100644
@@ -89,6 +89,7 @@ enum lockdown_reason {
 	LOCKDOWN_PCI_ACCESS,
 	LOCKDOWN_IOPORT,
 	LOCKDOWN_MSR,
+	LOCKDOWN_ACPI_TABLES,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index a01301972290..bfc0e088aa85 100644
@@ -25,6 +25,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_PCI_ACCESS] = "direct PCI access",
 	[LOCKDOWN_IOPORT] = "raw io port access",
 	[LOCKDOWN_MSR] = "raw MSR access",
+	[LOCKDOWN_ACPI_TABLES] = "modified ACPI tables",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#27 lore raw

PATCH v33 16/30 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..1f8f394fce34 100644
@@ -40,6 +40,7 @@
 #include <linux/list.h>
 #include <linux/jiffies.h>
 #include <linux/semaphore.h>
+#include <linux/security.h>
 
 #include <asm/io.h>
 #include <linux/uaccess.h>
@@ -194,7 +195,7 @@ acpi_physical_address __init acpi_os_get_root_pointer(void)
 	acpi_physical_address pa;
 
 #ifdef CONFIG_KEXEC
-	if (acpi_rsdp)
+	if (acpi_rsdp && !security_is_locked_down(LOCKDOWN_ACPI_TABLES))
 		return acpi_rsdp;
 #endif
 	pa = acpi_arch_get_root_pointer();
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#28 lore raw

PATCH v33 17/30 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 | 6 ++++++
 1 file changed, 6 insertions(+)
drivers/acpi/tables.c +6 -0
index 8fccbe49612a..f8e7d70f07ee 100644
@@ -34,6 +34,7 @@
 #include <linux/memblock.h>
 #include <linux/earlycpio.h>
 #include <linux/initrd.h>
+#include <linux/security.h>
 #include "internal.h"
 
 #ifdef CONFIG_ACPI_CUSTOM_DSDT
@@ -539,6 +540,11 @@ void __init acpi_table_upgrade(void)
 	if (table_nr == 0)
 		return;
 
+	if (security_is_locked_down(LOCKDOWN_ACPI_TABLES)) {
+		pr_notice("kernel is locked down, ignoring table override\n");
+		return;
+	}
+
 	acpi_tables_addr =
 		memblock_find_in_range(0, ACPI_TABLE_UPGRADE_MAX_PHYS,
 				       all_tables_size, PAGE_SIZE);
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#29 lore raw

PATCH v33 18/30 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 ++++
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 6 insertions(+)
drivers/pcmcia/cistpl.c +4 -0
index ac0672b8dfca..fb54e262578c 100644
@@ -24,6 +24,7 @@
 #include <linux/pci.h>
 #include <linux/ioport.h>
 #include <linux/io.h>
+#include <linux/security.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 
@@ -1578,6 +1579,9 @@ static ssize_t pccard_store_cis(struct file *filp, struct kobject *kobj,
 	struct pcmcia_socket *s;
 	int error;
 
+	if (security_is_locked_down(LOCKDOWN_PCMCIA_CIS))
+		return -EPERM;
+
 	s = to_socket(container_of(kobj, struct device, kobj));
 
 	if (off)
include/linux/security.h +1 -0
index 88d0f5d0cd87..87c433f1e7db 100644
@@ -90,6 +90,7 @@ enum lockdown_reason {
 	LOCKDOWN_IOPORT,
 	LOCKDOWN_MSR,
 	LOCKDOWN_ACPI_TABLES,
+	LOCKDOWN_PCMCIA_CIS,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index bfc0e088aa85..ced4ddbb36b4 100644
@@ -26,6 +26,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_IOPORT] = "raw io port access",
 	[LOCKDOWN_MSR] = "raw MSR access",
 	[LOCKDOWN_ACPI_TABLES] = "modified ACPI tables",
+	[LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#30 lore raw

PATCH v33 19/30 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 | 7 +++++++
 include/linux/security.h         | 1 +
 security/lockdown/lockdown.c     | 1 +
 3 files changed, 9 insertions(+)
drivers/tty/serial/serial_core.c +7 -0
index 351843f847c0..2dbef7dc23f6 100644
@@ -22,6 +22,7 @@
 #include <linux/serial_core.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
+#include <linux/security.h>
 
 #include <linux/irq.h>
 #include <linux/uaccess.h>
@@ -852,6 +853,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) &&
+	    security_is_locked_down(LOCKDOWN_TIOCSSERIAL)) {
+		retval = -EPERM;
+		goto exit;
+	}
+
 	if (!capable(CAP_SYS_ADMIN)) {
 		retval = -EPERM;
 		if (change_irq || change_port ||
include/linux/security.h +1 -0
index 87c433f1e7db..cb5d74f9b9ff 100644
@@ -91,6 +91,7 @@ enum lockdown_reason {
 	LOCKDOWN_MSR,
 	LOCKDOWN_ACPI_TABLES,
 	LOCKDOWN_PCMCIA_CIS,
+	LOCKDOWN_TIOCSSERIAL,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index ced4ddbb36b4..c6456f300220 100644
@@ -27,6 +27,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_MSR] = "raw MSR access",
 	[LOCKDOWN_ACPI_TABLES] = "modified ACPI tables",
 	[LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage",
+	[LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#31 lore raw

PATCH v33 20/30 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).

---
 include/linux/security.h     |  1 +
 kernel/params.c              | 27 ++++++++++++++++++++++-----
 security/lockdown/lockdown.c |  1 +
 3 files changed, 24 insertions(+), 5 deletions(-)
include/linux/security.h +1 -0
index cb5d74f9b9ff..47ca04ac00f6 100644
@@ -92,6 +92,7 @@ enum lockdown_reason {
 	LOCKDOWN_ACPI_TABLES,
 	LOCKDOWN_PCMCIA_CIS,
 	LOCKDOWN_TIOCSSERIAL,
+	LOCKDOWN_MODULE_PARAMETERS,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
kernel/params.c +22 -5
index ce89f757e6da..59544a2ec0b9 100644
@@ -24,6 +24,7 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/ctype.h>
+#include <linux/security.h>
 
 #ifdef CONFIG_SYSFS
 /* Protects all built-in parameters, modules use their own param_lock */
@@ -108,13 +109,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 &&
+	    security_is_locked_down(LOCKDOWN_MODULE_PARAMETERS))
+		return false;
+	return true;
 }
 
 static int parse_one(char *param,
@@ -144,8 +151,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 +562,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 +580,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;
security/lockdown/lockdown.c +1 -0
index c6456f300220..0788d4805449 100644
@@ -28,6 +28,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_ACPI_TABLES] = "modified ACPI tables",
 	[LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage",
 	[LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO",
+	[LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#32 lore raw

PATCH v33 21/30 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 +++
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 5 insertions(+)
arch/x86/mm/testmmiotrace.c +3 -0
index f6ae6830b341..a6b204f9f505 100644
@@ -115,6 +115,9 @@ static int __init init(void)
 {
 	unsigned long size = (read_far) ? (8 << 20) : (16 << 10);
 
+	if (security_is_locked_down(LOCKDOWN_MMIOTRACE))
+		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");
include/linux/security.h +1 -0
index 47ca04ac00f6..89b7adfae525 100644
@@ -93,6 +93,7 @@ enum lockdown_reason {
 	LOCKDOWN_PCMCIA_CIS,
 	LOCKDOWN_TIOCSSERIAL,
 	LOCKDOWN_MODULE_PARAMETERS,
+	LOCKDOWN_MMIOTRACE,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
security/lockdown/lockdown.c +1 -0
index 0788d4805449..215615e67237 100644
@@ -29,6 +29,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_PCMCIA_CIS] = "direct PCMCIA CIS storage",
 	[LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO",
 	[LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters",
+	[LOCKDOWN_MMIOTRACE] = "unsafe mmio",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
maintainer Acked-by on v33 21/30
#33 lore raw

Re: [PATCH V33 21/30] x86/mmiotrace: Lock down the testmmiotrace module

Quoted 8 lines · On Thu, 20 Jun 2019 18:19:32 -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 4 lines

-- Steve

Quoted 4 lines
cc Ingo Molnar <[email protected]>
cc "H. Peter Anvin" <[email protected]>

---

#34 lore raw

PATCH v33 22/30 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              | 3 +++
 include/linux/security.h     | 1 +
 security/lockdown/lockdown.c | 1 +
 3 files changed, 5 insertions(+)
fs/proc/kcore.c +3 -0
index d29d869abec1..b410a16b1960 100644
@@ -31,6 +31,7 @@
 #include <linux/ioport.h>
 #include <linux/memory.h>
 #include <linux/sched/task.h>
+#include <linux/security.h>
 #include <asm/sections.h>
 #include "internal.h"
 
@@ -545,6 +546,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 (security_is_locked_down(LOCKDOWN_KCORE))
+		return -EPERM;
 	if (!capable(CAP_SYS_RAWIO))
 		return -EPERM;
 
include/linux/security.h +1 -0
index 89b7adfae525..6752584729e2 100644
@@ -95,6 +95,7 @@ enum lockdown_reason {
 	LOCKDOWN_MODULE_PARAMETERS,
 	LOCKDOWN_MMIOTRACE,
 	LOCKDOWN_INTEGRITY_MAX,
+	LOCKDOWN_KCORE,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
 
security/lockdown/lockdown.c +1 -0
index 215615e67237..80ff4a31d8aa 100644
@@ -31,6 +31,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters",
 	[LOCKDOWN_MMIOTRACE] = "unsafe mmio",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
+	[LOCKDOWN_KCORE] = "/proc/kcore access",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
 
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#35 lore raw

PATCH v33 23/30 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.

---
 include/linux/security.h     | 1 +
 kernel/trace/trace_kprobe.c  | 4 ++++
 security/lockdown/lockdown.c | 1 +
 3 files changed, 6 insertions(+)
include/linux/security.h +1 -0
index 6752584729e2..dae4aa83352c 100644
@@ -96,6 +96,7 @@ enum lockdown_reason {
 	LOCKDOWN_MMIOTRACE,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_KCORE,
+	LOCKDOWN_KPROBES,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
 
kernel/trace/trace_kprobe.c +4 -0
index 5d5129b05df7..940ca20987aa 100644
@@ -11,6 +11,7 @@
 #include <linux/uaccess.h>
 #include <linux/rculist.h>
 #include <linux/error-injection.h>
+#include <linux/security.h>
 
 #include "trace_dynevent.h"
 #include "trace_kprobe_selftest.h"
@@ -415,6 +416,9 @@ static int __register_trace_kprobe(struct trace_kprobe *tk)
 {
 	int i, ret;
 
+	if (security_is_locked_down(LOCKDOWN_KPROBES))
+		return -EPERM;
+
 	if (trace_probe_is_registered(&tk->tp))
 		return -EINVAL;
 
security/lockdown/lockdown.c +1 -0
index 80ff4a31d8aa..89ad853daec2 100644
@@ -32,6 +32,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_MMIOTRACE] = "unsafe mmio",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_KCORE] = "/proc/kcore access",
+	[LOCKDOWN_KPROBES] = "use of kprobes",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
 
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#36 lore raw

PATCH v33 24/30 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.

---
 include/linux/security.h     |  1 +
 kernel/trace/bpf_trace.c     | 11 +++++++++++
 security/lockdown/lockdown.c |  1 +
 3 files changed, 13 insertions(+)
include/linux/security.h +1 -0
index dae4aa83352c..8bf426cdd151 100644
@@ -97,6 +97,7 @@ enum lockdown_reason {
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_KCORE,
 	LOCKDOWN_KPROBES,
+	LOCKDOWN_BPF,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
 
kernel/trace/bpf_trace.c +11 -0
index d64c00afceb5..6f57485df840 100644
@@ -137,6 +137,9 @@ BPF_CALL_3(bpf_probe_read, void *, dst, u32, size, const void *, unsafe_ptr)
 {
 	int ret;
 
+	if (security_is_locked_down(LOCKDOWN_BPF))
+		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 (security_is_locked_down(LOCKDOWN_BPF))
+		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 (security_is_locked_down(LOCKDOWN_BPF))
+		return -EINVAL;
+
 	/*
 	 * bpf_check()->check_func_arg()->check_stack_boundary()
 	 * guarantees that fmt points to bpf program stack,
@@ -534,6 +542,9 @@ BPF_CALL_3(bpf_probe_read_str, void *, dst, u32, size,
 {
 	int ret;
 
+	if (security_is_locked_down(LOCKDOWN_BPF))
+		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
security/lockdown/lockdown.c +1 -0
index 89ad853daec2..0a3bbf1ba01d 100644
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_KCORE] = "/proc/kcore access",
 	[LOCKDOWN_KPROBES] = "use of kprobes",
+	[LOCKDOWN_BPF] = "use of bpf",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
 
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
maintainer
#37 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 9 lines · 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.

This patch exemplifies why I don't like this approach:

Quoted 10 lines
include/linux/security.h +1 -0
@@ -97,6 +97,7 @@ enum lockdown_reason {
        LOCKDOWN_INTEGRITY_MAX,
        LOCKDOWN_KCORE,
        LOCKDOWN_KPROBES,
+       LOCKDOWN_BPF,
        LOCKDOWN_CONFIDENTIALITY_MAX,
 

security/lockdown/lockdown.c static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { · line 37

Quoted 5 lines
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
        [LOCKDOWN_INTEGRITY_MAX] = "integrity",
        [LOCKDOWN_KCORE] = "/proc/kcore access",
        [LOCKDOWN_KPROBES] = "use of kprobes",
+       [LOCKDOWN_BPF] = "use of bpf",
        [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",

The text here says "use of bpf", but what this patch is *really* doing is locking down use of BPF to read kernel memory. If the details change, then every LSM needs to get updated, and we risk breaking user policies that are based on LSMs that offer excessively fine granularity.

I'd be more comfortable if the LSM only got to see "confidentiality" or "integrity".

--Andy

#38 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 16 lines · Andy Lutomirski

security/lockdown/lockdown.c static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { · line 37

Quoted 8 lines · Matthew Garrett
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
        [LOCKDOWN_INTEGRITY_MAX] = "integrity",
        [LOCKDOWN_KCORE] = "/proc/kcore access",
        [LOCKDOWN_KPROBES] = "use of kprobes",
+       [LOCKDOWN_BPF] = "use of bpf",
        [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",

The text here says "use of bpf", but what this patch is *really* doing is locking down use of BPF to read kernel memory. If the details change, then every LSM needs to get updated, and we risk breaking user policies that are based on LSMs that offer excessively fine granularity.

The text is descriptive rather than normative, and no changes should be made that alter the semantics of a reason - it makes more sense to just add another reason.

Quoted 2 lines

I'd be more comfortable if the LSM only got to see "confidentiality" or "integrity".

If LSM authors can be trusted to do the right thing here, then I see no problem in providing additional data. I'm happy to defer to James on that.

maintainer
#39 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

In reply to Andy Lutomirski

[Adding the LSM mailing list: missed this patchset initially]

Quoted 9 lines · Andy Lutomirski

This patch exemplifies why I don't like this approach:

Quoted 6 lines
include/linux/security.h +1 -0
@@ -97,6 +97,7 @@ enum lockdown_reason {
        LOCKDOWN_INTEGRITY_MAX,
        LOCKDOWN_KCORE,
        LOCKDOWN_KPROBES,
+       LOCKDOWN_BPF,
        LOCKDOWN_CONFIDENTIALITY_MAX,
Quoted 14 lines

security/lockdown/lockdown.c static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { · line 37

Quoted 8 lines
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
        [LOCKDOWN_INTEGRITY_MAX] = "integrity",
        [LOCKDOWN_KCORE] = "/proc/kcore access",
        [LOCKDOWN_KPROBES] = "use of kprobes",
+       [LOCKDOWN_BPF] = "use of bpf",
        [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",

The text here says "use of bpf", but what this patch is *really* doing is locking down use of BPF to read kernel memory. If the details change, then every LSM needs to get updated, and we risk breaking user policies that are based on LSMs that offer excessively fine granularity.

Can you give an example of how the details might change?

Quoted 2 lines

I'd be more comfortable if the LSM only got to see "confidentiality" or "integrity".

These are not sufficient for creating a useful policy for the SELinux case.

Signature · 2 lines
James Morris
<[email protected]>
#40 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 32 lines · James Morris

[Adding the LSM mailing list: missed this patchset initially]

Quoted 11 lines · Andy Lutomirski

This patch exemplifies why I don't like this approach:

Quoted 6 lines
include/linux/security.h +1 -0
@@ -97,6 +97,7 @@ enum lockdown_reason {
       LOCKDOWN_INTEGRITY_MAX,
       LOCKDOWN_KCORE,
       LOCKDOWN_KPROBES,
+       LOCKDOWN_BPF,
       LOCKDOWN_CONFIDENTIALITY_MAX,
Quoted 14 lines

security/lockdown/lockdown.c static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { · line 37

Quoted 8 lines
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
       [LOCKDOWN_INTEGRITY_MAX] = "integrity",
       [LOCKDOWN_KCORE] = "/proc/kcore access",
       [LOCKDOWN_KPROBES] = "use of kprobes",
+       [LOCKDOWN_BPF] = "use of bpf",
       [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",

The text here says "use of bpf", but what this patch is *really* doing is locking down use of BPF to read kernel memory. If the details change, then every LSM needs to get updated, and we risk breaking user policies that are based on LSMs that offer excessively fine granularity.

Quoted 9 lines

Can you give an example of how the details might change?

Quoted 2 lines

I'd be more comfortable if the LSM only got to see "confidentiality" or "integrity".

These are not sufficient for creating a useful policy for the SELinux case.

I may have misunderstood, but I thought that SELinux mainly needed to allow certain privileged programs to bypass the policy. Is there a real example of what SELinux wants to do that can’t be done in the simplified model?

The think that specifically makes me uneasy about exposing all of these precise actions to LSMs is that they will get exposed to userspace in a way that forces us to treat them as stable ABIs.

#41 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 37 lines · Andy Lutomirski
Quoted 37 lines · James Morris

[Adding the LSM mailing list: missed this patchset initially]

Quoted 11 lines · Andy Lutomirski

This patch exemplifies why I don't like this approach:

Quoted 6 lines
include/linux/security.h +1 -0
@@ -97,6 +97,7 @@ enum lockdown_reason {
        LOCKDOWN_INTEGRITY_MAX,
        LOCKDOWN_KCORE,
        LOCKDOWN_KPROBES,
+       LOCKDOWN_BPF,
        LOCKDOWN_CONFIDENTIALITY_MAX,
Quoted 14 lines

security/lockdown/lockdown.c static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { · line 37

Quoted 8 lines
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
        [LOCKDOWN_INTEGRITY_MAX] = "integrity",
        [LOCKDOWN_KCORE] = "/proc/kcore access",
        [LOCKDOWN_KPROBES] = "use of kprobes",
+       [LOCKDOWN_BPF] = "use of bpf",
        [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",

The text here says "use of bpf", but what this patch is *really* doing is locking down use of BPF to read kernel memory. If the details change, then every LSM needs to get updated, and we risk breaking user policies that are based on LSMs that offer excessively fine granularity.

Can you give an example of how the details might change?

Quoted 2 lines

I'd be more comfortable if the LSM only got to see "confidentiality" or "integrity".

Quoted 8 lines
Quoted 4 lines

These are not sufficient for creating a useful policy for the SELinux case.

I may have misunderstood, but I thought that SELinux mainly needed to allow certain privileged programs to bypass the policy. Is there a real example of what SELinux wants to do that can’t be done in the simplified model?

The think that specifically makes me uneasy about exposing all of these precise actions to LSMs is that they will get exposed to userspace in a way that forces us to treat them as stable ABIs.

There are two scenarios where finer-grained distinctions make sense:

- Users may need to enable specific functionality that falls under the umbrella of "confidentiality" or "integrity" lockdown. Finer-grained lockdown reasons free them from having to make an all-or-nothing choice between lost functionality or no lockdown at all. This can be supported directly by the lockdown module without any help from SELinux or other security modules; we just need the ability to specify these finer-grained lockdown levels via the boot parameters and securityfs nodes.

- Different processes/programs may need to use different sets of functionality restricted via lockdown confidentiality or integrity categories. If we have to allow all-or-none for the set of interfaces/functionality covered by the generic confidentiality or integrity categories, then we'll end up having to choose between lost functionality or overprivileged processes, neither of which is optimal.

Is it truly the case that everything under the "confidentiality" category poses the same level of risk to kernel confidentiality, and similarly for everything under the "integrity" category? If not, then being able to distinguish them definitely has benefit.

I'm still not clear though on how/if this will compose with or be overridden by other security modules. We would need some means for another security module to take over lockdown decisions once it has initialized (including policy load), and to be able to access state that is currently private to the lockdown module, like the level.

maintainer
#42 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 6 lines · Stephen Smalley

There are two scenarios where finer-grained distinctions make sense:

- Users may need to enable specific functionality that falls under the umbrella of "confidentiality" or "integrity" lockdown. Finer-grained lockdown reasons free them from having to make an all-or-nothing choice between lost functionality or no lockdown at all.

Agreed. This will be used for more than just UEFI secure boot on desktops, e.g. embedded systems using verified boot, where finer grained policy will be needed for what are sometimes very specific use-cases (which may be also covered by other mitigations).

Quoted 4 lines

This can be supported directly by the
lockdown module without any help from SELinux or other security modules; we just need the ability to specify these finer-grained lockdown levels via the boot parameters and securityfs nodes.

If the lockdown LSM implements fine grained policy (rather than the simple coarse grained policy), I'd suggest adding a new lockdown level of 'custom' which by default enables all hooks but allows selective disablement via params/sysfs.

This would be simpler than telling users to use a different lockdown LSM for this.

Quoted 11 lines

- Different processes/programs may need to use different sets of functionality restricted via lockdown confidentiality or integrity categories. If we have to allow all-or-none for the set of interfaces/functionality covered by the generic confidentiality or integrity categories, then we'll end up having to choose between lost functionality or overprivileged processes, neither of which is optimal.

Is it truly the case that everything under the "confidentiality" category poses the same level of risk to kernel confidentiality, and similarly for everything under the "integrity" category? If not, then being able to distinguish them definitely has benefit.

Good question. We can't know the answer to this unless we know how an attacker might leverage access.

The value here IMHO is more in allowing tradeoffs to be made by system designers vs. disabling lockdown entirely.

Quoted 5 lines

I'm still not clear though on how/if this will compose with or be overridden by other security modules. We would need some means for another security module to take over lockdown decisions once it has initialized (including policy load), and to be able to access state that is currently private to the lockdown module, like the level.

Why not utilize stacking (restrictively), similarly to capabilities?

Signature · 2 lines
James Morris
<[email protected]>
#43 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 45 lines · James Morris
Quoted 6 lines · Stephen Smalley

There are two scenarios where finer-grained distinctions make sense:

- Users may need to enable specific functionality that falls under the umbrella of "confidentiality" or "integrity" lockdown. Finer-grained lockdown reasons free them from having to make an all-or-nothing choice between lost functionality or no lockdown at all.

Agreed. This will be used for more than just UEFI secure boot on desktops, e.g. embedded systems using verified boot, where finer grained policy will be needed for what are sometimes very specific use-cases (which may be also covered by other mitigations).

Quoted 4 lines

This can be supported directly by the
lockdown module without any help from SELinux or other security modules; we just need the ability to specify these finer-grained lockdown levels via the boot parameters and securityfs nodes.

If the lockdown LSM implements fine grained policy (rather than the simple coarse grained policy), I'd suggest adding a new lockdown level of 'custom' which by default enables all hooks but allows selective disablement via params/sysfs.

This would be simpler than telling users to use a different lockdown LSM for this.

Quoted 11 lines

- Different processes/programs may need to use different sets of functionality restricted via lockdown confidentiality or integrity categories. If we have to allow all-or-none for the set of interfaces/functionality covered by the generic confidentiality or integrity categories, then we'll end up having to choose between lost functionality or overprivileged processes, neither of which is optimal.

Is it truly the case that everything under the "confidentiality" category poses the same level of risk to kernel confidentiality, and similarly for everything under the "integrity" category? If not, then being able to distinguish them definitely has benefit.

Good question. We can't know the answer to this unless we know how an attacker might leverage access.

The value here IMHO is more in allowing tradeoffs to be made by system designers vs. disabling lockdown entirely.

Quoted 7 lines
Quoted 5 lines

I'm still not clear though on how/if this will compose with or be overridden by other security modules. We would need some means for another security module to take over lockdown decisions once it has initialized (including policy load), and to be able to access state that is currently private to the lockdown module, like the level.

Why not utilize stacking (restrictively), similarly to capabilities?

That would only allow the LSM to further lock down the system above the lockdown level set at boot, not grant exemptions for specific functionality/interfaces required by the user or by a specific process/program. You'd have to boot with lockdown=none (or your lockdown=custom suggestion) in order for the LSM to allow anything covered by the integrity or confidentiality levels. And then the kernel would be unprotected prior to full initialization of the LSM, including policy load.

It seems like one would want to be able to boot with lockdown=integrity to protect the kernel initially, then switch over to allowing the LSM to selectively override it.

#44 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 9 lines · Stephen Smalley

That would only allow the LSM to further lock down the system above the lockdown level set at boot, not grant exemptions for specific functionality/interfaces required by the user or by a specific process/program. You'd have to boot with lockdown=none (or your lockdown=custom suggestion) in order for the LSM to allow anything covered by the integrity or confidentiality levels. And then the kernel would be unprotected prior to full initialization of the LSM, including policy load.

Quoted 3 lines

It seems like one would want to be able to boot with lockdown=integrity to protect the kernel initially, then switch over to allowing the LSM to selectively override it.

One option would be to allow modules to be "unstacked" at runtime, but there's still something of a problem here - how do you ensure that your userland can be trusted to load a new policy before it does so? If you're able to assert that your early userland is trustworthy (perhaps because it's in an initramfs that's part of your signed boot payload), there's maybe an argument that most of the lockdown integrity guarantees are unnecessary before handoff - just using the lockdown LSM to protect against attacks via kernel parameters would be sufficient.

maintainer
#45 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 15 lines · Matthew Garrett
Quoted 9 lines · Stephen Smalley

That would only allow the LSM to further lock down the system above the lockdown level set at boot, not grant exemptions for specific functionality/interfaces required by the user or by a specific process/program. You'd have to boot with lockdown=none (or your lockdown=custom suggestion) in order for the LSM to allow anything covered by the integrity or confidentiality levels. And then the kernel would be unprotected prior to full initialization of the LSM, including policy load.

Quoted 3 lines

It seems like one would want to be able to boot with lockdown=integrity to protect the kernel initially, then switch over to allowing the LSM to selectively override it.

Quoted 9 lines

One option would be to allow modules to be "unstacked" at runtime, but there's still something of a problem here - how do you ensure that your userland can be trusted to load a new policy before it does so? If you're able to assert that your early userland is trustworthy (perhaps because it's in an initramfs that's part of your signed boot payload), there's maybe an argument that most of the lockdown integrity guarantees are unnecessary before handoff - just using the lockdown LSM to protect against attacks via kernel parameters would be sufficient.

I think that, if you don't trust your system enough to avoid compromising itself before policy load, then your MAC policy is more or less dead in the water. It seems to be that it ought to be good enough to boot with lockdown=none and then have a real policy loaded along with the rest of the MAC policy. Or, for applications that need to be stricter, you accept that MAC policy can't override lockdown.

maintainer
#46 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

In reply to Stephen Smalley
Quoted 65 lines · Stephen Smalley
Quoted 37 lines · Andy Lutomirski
Quoted 37 lines · James Morris

[Adding the LSM mailing list: missed this patchset initially]

Quoted 11 lines · Andy Lutomirski

This patch exemplifies why I don't like this approach:

Quoted 6 lines
include/linux/security.h +1 -0
@@ -97,6 +97,7 @@ enum lockdown_reason {
        LOCKDOWN_INTEGRITY_MAX,
        LOCKDOWN_KCORE,
        LOCKDOWN_KPROBES,
+       LOCKDOWN_BPF,
        LOCKDOWN_CONFIDENTIALITY_MAX,
Quoted 14 lines

security/lockdown/lockdown.c static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = { · line 37

Quoted 8 lines
security/lockdown/lockdown.c +1 -0
@@ -33,6 +33,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
        [LOCKDOWN_INTEGRITY_MAX] = "integrity",
        [LOCKDOWN_KCORE] = "/proc/kcore access",
        [LOCKDOWN_KPROBES] = "use of kprobes",
+       [LOCKDOWN_BPF] = "use of bpf",
        [LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",

The text here says "use of bpf", but what this patch is *really* doing is locking down use of BPF to read kernel memory. If the details change, then every LSM needs to get updated, and we risk breaking user policies that are based on LSMs that offer excessively fine granularity.

Can you give an example of how the details might change?

Quoted 2 lines

I'd be more comfortable if the LSM only got to see "confidentiality" or "integrity".

Quoted 8 lines
Quoted 4 lines

These are not sufficient for creating a useful policy for the SELinux case.

I may have misunderstood, but I thought that SELinux mainly needed to allow certain privileged programs to bypass the policy. Is there a real example of what SELinux wants to do that can’t be done in the simplified model?

The think that specifically makes me uneasy about exposing all of these precise actions to LSMs is that they will get exposed to userspace in a way that forces us to treat them as stable ABIs.

There are two scenarios where finer-grained distinctions make sense:

- Users may need to enable specific functionality that falls under the umbrella of "confidentiality" or "integrity" lockdown. Finer-grained lockdown reasons free them from having to make an all-or-nothing choice between lost functionality or no lockdown at all. This can be supported directly by the lockdown module without any help from SELinux or other security modules; we just need the ability to specify these finer-grained lockdown levels via the boot parameters and securityfs nodes.

- Different processes/programs may need to use different sets of functionality restricted via lockdown confidentiality or integrity categories. If we have to allow all-or-none for the set of interfaces/functionality covered by the generic confidentiality or integrity categories, then we'll end up having to choose between lost functionality or overprivileged processes, neither of which is optimal.

Quoted 5 lines

Is it truly the case that everything under the "confidentiality" category poses the same level of risk to kernel confidentiality, and similarly for everything under the "integrity" category? If not, then being able to distinguish them definitely has benefit.

They're really quite similar in my mind. Certainly some things in the "integrity" category give absolutely trivial control over the kernel (e.g. modules) while others make it quite challenging (ioperm), but the end result is very similar. And quite a few "confidentiality" things genuinely do allow all kernel memory to be read.

I agree that finer-grained distinctions could be useful. My concern is that it's a tradeoff, and the other end of the tradeoff is an ABI stability issue. If someone decides down the road that some feature that is currently "integrity" can be split into a narrow "integrity" feature and a "confidentiality" feature then, if the user policy knows about the individual features, there's a risk of breaking people's systems. If we keep the fine-grained control, do we have a clear compatibility story?

#47 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 6 lines · Andy Lutomirski

They're really quite similar in my mind. Certainly some things in the "integrity" category give absolutely trivial control over the kernel (e.g. modules) while others make it quite challenging (ioperm), but the end result is very similar. And quite a few "confidentiality" things genuinely do allow all kernel memory to be read.

Quoted 8 lines

I agree that finer-grained distinctions could be useful. My concern is that it's a tradeoff, and the other end of the tradeoff is an ABI stability issue. If someone decides down the road that some feature that is currently "integrity" can be split into a narrow "integrity" feature and a "confidentiality" feature then, if the user policy knows about the individual features, there's a risk of breaking people's systems. If we keep the fine-grained control, do we have a clear compatibility story?

My preference right now is to retain the fine-grained aspect of things in the internal API, simply because it'll be more annoying to add it back later if we want to. I don't want to expose it via the Lockdown user facing API for the reasons you've described, but it's not impossible that another LSM would find a way to do this reasonably. Does it seem reasonable to punt this discussion out to the point where another LSM tries to do something with this information, based on the implementation they're attempting?

maintainer
#48 lore raw

Re: [PATCH V33 24/30] bpf: Restrict bpf when kernel lockdown is in confidentiality mode

Quoted 17 lines · Matthew Garrett
Quoted 6 lines · Andy Lutomirski

They're really quite similar in my mind. Certainly some things in the "integrity" category give absolutely trivial control over the kernel (e.g. modules) while others make it quite challenging (ioperm), but the end result is very similar. And quite a few "confidentiality" things genuinely do allow all kernel memory to be read.

Quoted 8 lines

I agree that finer-grained distinctions could be useful. My concern is that it's a tradeoff, and the other end of the tradeoff is an ABI stability issue. If someone decides down the road that some feature that is currently "integrity" can be split into a narrow "integrity" feature and a "confidentiality" feature then, if the user policy knows about the individual features, there's a risk of breaking people's systems. If we keep the fine-grained control, do we have a clear compatibility story?

Quoted 8 lines

My preference right now is to retain the fine-grained aspect of things in the internal API, simply because it'll be more annoying to add it back later if we want to. I don't want to expose it via the Lockdown user facing API for the reasons you've described, but it's not impossible that another LSM would find a way to do this reasonably. Does it seem reasonable to punt this discussion out to the point where another LSM tries to do something with this information, based on the implementation they're attempting?

I think I can get behind this, as long as it's clear to LSM authors that this list is only a little bit stable. I can certainly see the use for the fine-grained info being available for auditing.

#49 lore raw

PATCH v33 25/30 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]>
---
 include/linux/security.h     | 1 +
 kernel/events/core.c         | 5 +++++
 security/lockdown/lockdown.c | 1 +
 3 files changed, 7 insertions(+)
include/linux/security.h +1 -0
index 8bf426cdd151..36a9daa13bb0 100644
@@ -98,6 +98,7 @@ enum lockdown_reason {
 	LOCKDOWN_KCORE,
 	LOCKDOWN_KPROBES,
 	LOCKDOWN_BPF,
+	LOCKDOWN_PERF,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
 
kernel/events/core.c +5 -0
index 72d06e302e99..ac1045caa44d 100644
@@ -10731,6 +10731,11 @@ SYSCALL_DEFINE5(perf_event_open,
 			return -EINVAL;
 	}
 
+	if ((attr.sample_type & PERF_SAMPLE_REGS_INTR) &&
+	    security_is_locked_down(LOCKDOWN_PERF))
+		/* 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))
security/lockdown/lockdown.c +1 -0
index 0a3bbf1ba01d..14edc475d75c 100644
@@ -34,6 +34,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_KCORE] = "/proc/kcore access",
 	[LOCKDOWN_KPROBES] = "use of kprobes",
 	[LOCKDOWN_BPF] = "use of bpf",
+	[LOCKDOWN_PERF] = "unsafe use of perf",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
 
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#50 lore raw

PATCH v33 26/30 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 dc12fbcf484c..c30954acc660 100644
@@ -132,4 +132,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 455f4fc794f3..8134da6573c6 100644
@@ -240,7 +240,12 @@ kimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd,
 
 		ret = 0;
 
-		if (security_is_locked_down(LOCKDOWN_KEXEC)) {
+		/* If IMA is guaranteed to appraise a signature on the kexec
+		 * image, permit it even if the kernel is otherwise locked
+		 * down.
+		 */
+		if (!ima_appraise_signature(READING_KEXEC_IMAGE) &&
+		    security_is_locked_down(LOCKDOWN_KEXEC)) {
 			ret = -EPERM;
 			goto out;
 		}
security/integrity/ima/ima.h +2 -0
index d213e835c498..3bc62062cfe8 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 357edd140c09..927fe889201a 100644
@@ -473,7 +473,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.22.0.410.gd8fdbe21b5-goog
#51 lore raw

PATCH v33 27/30 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/lockdown/lockdown.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
security/lockdown/lockdown.c +2 -2
index 14edc475d75c..408f0048f8a2 100644
@@ -80,8 +80,8 @@ early_param("lockdown", lockdown_param);
 static int lockdown_is_locked_down(enum lockdown_reason what)
 {	
 	if ((kernel_locked_down >= what) && lockdown_reasons[what])
-		pr_notice("Lockdown: %s is restricted; see man kernel_lockdown.7\n",
-			  lockdown_reasons[what]);
+		pr_notice("Lockdown: %s: %s is restricted; see man kernel_lockdown.7\n",
+			  current->comm, lockdown_reasons[what]);
 	return (kernel_locked_down >= what);
 }
 
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#52 lore raw

Re: [PATCH V33 27/30] lockdown: Print current->comm in restriction messages

Quoted 19 lines · 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/lockdown/lockdown.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
security/lockdown/lockdown.c +0 -0
index 14edc475d75c..408f0048f8a2 100644

security/lockdown/lockdown.c early_param("lockdown", lockdown_param); · line 86

Quoted 9 lines
security/lockdown/lockdown.c +2 -2
@@ -80,8 +80,8 @@ early_param("lockdown", lockdown_param);
 static int lockdown_is_locked_down(enum lockdown_reason what)
 {	
 	if ((kernel_locked_down >= what) && lockdown_reasons[what])
-		pr_notice("Lockdown: %s is restricted; see man kernel_lockdown.7\n",
-			  lockdown_reasons[what]);
+		pr_notice("Lockdown: %s: %s is restricted; see man kernel_lockdown.7\n",
+			  current->comm, lockdown_reasons[what]);
 	return (kernel_locked_down >= what);
 }

Maybe needs ratelimiting?

Quoted 4 lines
Signature · 2 lines
-- 
2.22.0.410.gd8fdbe21b5-goog
Signature · 1 line
Kees Cook
#53 lore raw

PATCH v33 28/30 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            | 31 +++++++++++++++++++++++++++++++
 fs/debugfs/inode.c           | 31 +++++++++++++++++++++++++++++--
 include/linux/security.h     |  1 +
 security/lockdown/lockdown.c |  1 +
 4 files changed, 62 insertions(+), 2 deletions(-)
fs/debugfs/file.c +31 -0
index 4fce1da7db23..227b147350b7 100644
@@ -19,6 +19,7 @@
 #include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/poll.h>
+#include <linux/security.h>
 
 #include "internal.h"
 
@@ -136,6 +137,25 @@ void debugfs_file_put(struct dentry *dentry)
 }
 EXPORT_SYMBOL_GPL(debugfs_file_put);
 
+/*
+ * Only permit access to world-readable files when the kernel is locked down.
+ * We also need to exclude any file that has ways to write or alter it as root
+ * can bypass the permissions check.
+ */
+static bool debugfs_is_locked_down(struct inode *inode,
+				   struct file *filp,
+				   const struct file_operations *real_fops)
+{
+	if ((inode->i_mode & 07777) == 0444 &&
+	    !(filp->f_mode & FMODE_WRITE) &&
+	    !real_fops->unlocked_ioctl &&
+	    !real_fops->compat_ioctl &&
+	    !real_fops->mmap)
+		return false;
+
+	return security_is_locked_down(LOCKDOWN_DEBUGFS);
+}
+
 static int open_proxy_open(struct inode *inode, struct file *filp)
 {
 	struct dentry *dentry = F_DENTRY(filp);
@@ -147,6 +167,12 @@ static int open_proxy_open(struct inode *inode, struct file *filp)
 		return r == -EIO ? -ENOENT : r;
 
 	real_fops = debugfs_real_fops(filp);
+
+	if (debugfs_is_locked_down(inode, filp, real_fops)) {
+		r = -EPERM;
+		goto out;
+	}
+
 	real_fops = fops_get(real_fops);
 	if (!real_fops) {
 		/* Huh? Module did not clean up after itself at exit? */
@@ -272,6 +298,11 @@ static int full_proxy_open(struct inode *inode, struct file *filp)
 		return r == -EIO ? -ENOENT : r;
 
 	real_fops = debugfs_real_fops(filp);
+	if (debugfs_is_locked_down(inode, filp, real_fops)) {
+		r = -EPERM;
+		goto out;
+	}
+
 	real_fops = fops_get(real_fops);
 	if (!real_fops) {
 		/* Huh? Module did not cleanup after itself at exit? */
fs/debugfs/inode.c +29 -2
index 95b5e78c22b1..76b24fb3c911 100644
@@ -23,6 +23,7 @@
 #include <linux/parser.h>
 #include <linux/magic.h>
 #include <linux/slab.h>
+#include <linux/security.h>
 
 #include "internal.h"
 
@@ -32,6 +33,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)) &&
+	    security_is_locked_down(LOCKDOWN_DEBUGFS))
+		return -EPERM;
+	return simple_setattr(dentry, ia);
+}
+
+static const struct inode_operations debugfs_file_inode_operations = {
+	.setattr	= debugfs_setattr,
+};
+static const struct inode_operations debugfs_dir_inode_operations = {
+	.lookup		= simple_lookup,
+	.setattr	= debugfs_setattr,
+};
+static const struct inode_operations debugfs_symlink_inode_operations = {
+	.get_link	= simple_get_link,
+	.setattr	= debugfs_setattr,
+};
+
 static struct inode *debugfs_get_inode(struct super_block *sb)
 {
 	struct inode *inode = new_inode(sb);
@@ -356,6 +382,7 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
 	inode->i_mode = mode;
 	inode->i_private = data;
 
+	inode->i_op = &debugfs_file_inode_operations;
 	inode->i_fop = proxy_fops;
 	dentry->d_fsdata = (void *)((unsigned long)real_fops |
 				DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
@@ -516,7 +543,7 @@ struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
 		return failed_creating(dentry);
 
 	inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
-	inode->i_op = &simple_dir_inode_operations;
+	inode->i_op = &debugfs_dir_inode_operations;
 	inode->i_fop = &simple_dir_operations;
 
 	/* directory inodes start off with i_nlink == 2 (for "." entry) */
@@ -611,7 +638,7 @@ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
 		return failed_creating(dentry);
 	}
 	inode->i_mode = S_IFLNK | S_IRWXUGO;
-	inode->i_op = &simple_symlink_inode_operations;
+	inode->i_op = &debugfs_symlink_inode_operations;
 	inode->i_link = link;
 	d_instantiate(dentry, inode);
 	return end_creating(dentry);
include/linux/security.h +1 -0
index 36a9daa13bb0..2563a9e3b415 100644
@@ -94,6 +94,7 @@ enum lockdown_reason {
 	LOCKDOWN_TIOCSSERIAL,
 	LOCKDOWN_MODULE_PARAMETERS,
 	LOCKDOWN_MMIOTRACE,
+	LOCKDOWN_DEBUGFS,
 	LOCKDOWN_INTEGRITY_MAX,
 	LOCKDOWN_KCORE,
 	LOCKDOWN_KPROBES,
security/lockdown/lockdown.c +1 -0
index 408f0048f8a2..a6f7b0770e78 100644
@@ -30,6 +30,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_TIOCSSERIAL] = "reconfiguration of serial port IO",
 	[LOCKDOWN_MODULE_PARAMETERS] = "unsafe module parameters",
 	[LOCKDOWN_MMIOTRACE] = "unsafe mmio",
+	[LOCKDOWN_DEBUGFS] = "debugfs access",
 	[LOCKDOWN_INTEGRITY_MAX] = "integrity",
 	[LOCKDOWN_KCORE] = "/proc/kcore access",
 	[LOCKDOWN_KPROBES] = "use of kprobes",
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#54 lore raw

PATCH v33 29/30 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           | 41 +++++++++++++++++++++++++++++++++++-
 include/linux/security.h     |  1 +
 security/lockdown/lockdown.c |  1 +
 3 files changed, 42 insertions(+), 1 deletion(-)
fs/tracefs/inode.c +40 -1
index 7098c49f3693..f6c04fa8e415 100644
@@ -24,6 +24,7 @@
 #include <linux/parser.h>
 #include <linux/magic.h>
 #include <linux/slab.h>
+#include <linux/security.h>
 
 #define TRACEFS_DEFAULT_MODE	0700
 
@@ -31,6 +32,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 (security_is_locked_down(LOCKDOWN_TRACEFS))
+		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 +66,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 +248,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 +289,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 +423,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 +437,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);
include/linux/security.h +1 -0
index 2563a9e3b415..040e7fc33397 100644
@@ -100,6 +100,7 @@ enum lockdown_reason {
 	LOCKDOWN_KPROBES,
 	LOCKDOWN_BPF,
 	LOCKDOWN_PERF,
+	LOCKDOWN_TRACEFS,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
 
security/lockdown/lockdown.c +1 -0
index a6f7b0770e78..7dc601f06cd3 100644
@@ -36,6 +36,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_KPROBES] = "use of kprobes",
 	[LOCKDOWN_BPF] = "use of bpf",
 	[LOCKDOWN_PERF] = "unsafe use of perf",
+	[LOCKDOWN_TRACEFS] = "use of tracefs",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
 
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
maintainer
#55 lore raw

Re: [PATCH V33 29/30] tracefs: Restrict tracefs when the kernel is locked down

Quoted 47 lines · On Thu, 20 Jun 2019 18:19:40 -0700 Matthew Garrett <[email protected]>…

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           | 41 +++++++++++++++++++++++++++++++++++-
 include/linux/security.h     |  1 +
 security/lockdown/lockdown.c |  1 +
 3 files changed, 42 insertions(+), 1 deletion(-)
fs/tracefs/inode.c +16 -0
index 7098c49f3693..f6c04fa8e415 100644
@@ -24,6 +24,7 @@
 #include <linux/parser.h>
 #include <linux/magic.h>
 #include <linux/slab.h>
+#include <linux/security.h>
 
 #define TRACEFS_DEFAULT_MODE	0700
 
@@ -31,6 +32,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 (security_is_locked_down(LOCKDOWN_TRACEFS))
+		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)
 {

fs/tracefs/inode.c static const struct file_operations tracefs_file_operations = { · line 74

Quoted 9 lines
fs/tracefs/inode.c +6 -0
@@ -50,6 +66,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,
+};

This appears to be unused.

Quoted 38 lines
fs/tracefs/inode.c +10 -0
+
 static struct tracefs_dir_ops {
 	int (*mkdir)(const char *name);
 	int (*rmdir)(const char *name);
@@ -225,6 +248,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 +289,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 +423,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 +437,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);

fs/tracefs/inode.c struct dentry *tracefs_create_file(const char *name, umode_t mode, · line 449

Quoted 10 lines
fs/tracefs/inode.c +8 -1
+	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;

I think the above would look cleaner as:

	if (!fops)
		fops = &tracefs_file_operations;

	dentry->d_fsdata = (void *)fops;
	memcpy(proxy_fops, fops, sizeof(*proxy_fops);
	proxy_fops->open = default_open_file;

-- Steve

Quoted 27 lines
fs/tracefs/inode.c +0 -0
 	inode->i_private = data;
 	d_instantiate(dentry, inode);
 	fsnotify_create(dentry->d_parent->d_inode, dentry);
include/linux/security.h +1 -0
index 2563a9e3b415..040e7fc33397 100644
@@ -100,6 +100,7 @@ enum lockdown_reason {
 	LOCKDOWN_KPROBES,
 	LOCKDOWN_BPF,
 	LOCKDOWN_PERF,
+	LOCKDOWN_TRACEFS,
 	LOCKDOWN_CONFIDENTIALITY_MAX,
 };
 
security/lockdown/lockdown.c +1 -0
index a6f7b0770e78..7dc601f06cd3 100644
@@ -36,6 +36,7 @@ static char *lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
 	[LOCKDOWN_KPROBES] = "use of kprobes",
 	[LOCKDOWN_BPF] = "use of bpf",
 	[LOCKDOWN_PERF] = "unsafe use of perf",
+	[LOCKDOWN_TRACEFS] = "use of tracefs",
 	[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
 };
 
#56 lore raw

Re: [PATCH V33 29/30] tracefs: Restrict tracefs when the kernel is locked down

Quoted 11 lines · Steven Rostedt

fs/tracefs/inode.c static const struct file_operations tracefs_file_operations = { · line 74

Quoted 6 lines · On Thu, 20 Jun 2019 18:19:40 -0700 Matthew Garrett <[email protected]>…
fs/tracefs/inode.c +6 -0
+static const struct file_operations tracefs_proxy_file_operations = {
+     .read =         default_read_file,
+     .write =        default_write_file,
+     .open =         default_open_file,
+     .llseek =       noop_llseek,
+};

This appears to be unused.

Oops, yup - dropped.

Quoted 12 lines

fs/tracefs/inode.c struct dentry *tracefs_create_file(const char *name, umode_t mode, · line 449

Quoted 7 lines
fs/tracefs/inode.c +5 -1
+     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;

I think the above would look cleaner as:

Quoted 6 lines
        if (!fops)
                fops = &tracefs_file_operations;

        dentry->d_fsdata = (void *)fops;
        memcpy(proxy_fops, fops, sizeof(*proxy_fops);
        proxy_fops->open = default_open_file;

ACK.

#57 lore raw

PATCH v33 30/30 efi: Restrict efivar_ssdt_load when the kernel is locked down

In reply to Matthew Garrett

efivar_ssdt_load allows the kernel to import arbitrary ACPI code from an EFI variable, which gives arbitrary code execution in ring 0. Prevent that when the kernel is locked down.

---
 drivers/firmware/efi/efi.c | 4 ++++
 1 file changed, 4 insertions(+)
drivers/firmware/efi/efi.c +4 -0
index 55b77c576c42..a9ea649e0512 100644
@@ -31,6 +31,7 @@
 #include <linux/acpi.h>
 #include <linux/ucs2_string.h>
 #include <linux/memblock.h>
+#include <linux/security.h>
 
 #include <asm/early_ioremap.h>
 
@@ -242,6 +243,9 @@ static void generic_ops_unregister(void)
 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
 static int __init efivar_ssdt_setup(char *str)
 {
+	if (security_is_locked_down(LOCKDOWN_ACPI_TABLES))
+		return -EPERM;
+
 	if (strlen(str) < sizeof(efivar_ssdt))
 		memcpy(efivar_ssdt, str, strlen(str));
 	else
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog