Skip to contentSkip to conversation

Smack: Don't register smackfs if we're not loaded

PATCH In review Ahmed S. Darwish 3 participants 9 messages Mar 4, 2008 – Mar 5, 2008

Subsystems (4)
Documentation SELinux security module Security (LSM) Smack security module
lore
Share & tools
lore

Ahmed S. Darwish

author
#0 lore raw

PATCH 1/1 Smack: Don't register smackfs if we're not loaded

Hi all,

Smackfs initialization without an enabled Smack leads to an early Oops that renders the system unusable.

Introduce a global smack_enabled variable that will be used to make sure that no smack components will be registered (ala smackfs) if we are not already enabled.

Signed-off-by Ahmed S. Darwish <[email protected]>

---

The Oops is triggered by the security= patch that will be sent soon.

I can't imagine an SELinux guru finding /smackfs instead of his usual /selinuxfs when he hits a tab completion after 's' ;). As a bonus, this patch will handle that case too.

 smack.h     |    9 +++++++++
 smack_lsm.c |    8 ++++++++
 smackfs.c   |    3 +++
 3 files changed, 20 insertions(+)
security/smack/smack.h +9 -0
index a21a0e9..17c55ad 100644
@@ -18,6 +18,15 @@
 #include <net/netlabel.h>
 
 /*
+ * We must not bother the rest of the kernel by exporting our
+ * own stuff if we are not already enabled. We may not be loaded
+ * if another or no LSM was chosen on boot.
+ * Smackfs is currently the only exported component, but this
+ * may change in the future.
+ */
+extern int smack_enabled;
+
+/*
  * Why 23? CIPSO is constrained to 30, so a 32 byte buffer is
  * bigger than can be used, and 24 is the next lower multiple
  * of 8, and there are too many issues if there isn't space set
security/smack/smack_lsm.c +8 -0
index 770eb06..6fe7869 100644
@@ -36,6 +36,8 @@
 #define SOCKFS_MAGIC		0x534F434B
 #define TMPFS_MAGIC		0x01021994
 
+int smack_enabled;
+
 /**
  * smk_fetch - Fetch the smack label from a file.
  * @ip: a pointer to the inode

@@ -2589,6 +2591,12 @@ static __init int smack_init(void)
 	if (register_security(&smack_ops))
 		panic("smack: Unable to register with kernel.\n");
 
+	/*
+	 * Notify other Smack components that it's now safe to
+	 * to register themselves.
+	 */
+	smack_enabled = 1;
+
 	return 0;
 }
security/smack/smackfs.c +3 -0
index 358c92c..e1687c0 100644
@@ -992,6 +992,9 @@ static int __init init_smk_fs(void)
 {
 	int err;
 
+	if (!smack_enabled)
+		return 0;
+
 	err = register_filesystem(&smk_fs_type);
 	if (!err) {
 		smackfs_mount = kern_mount(&smk_fs_type);
Signature · 5 lines
"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com
author
#1 lore raw

PATCH 1/1 Security: Introduce security= boot parameter

Hi all,

[
Sending as a reply to the above Smack bugfix cause the bug is triggered by this patch.

Please merge the bugfix before this.

IMHO this patch (or similar) is needed before the release to avoid useless panics. Also as noted by Alexey, current allyesconfig kernels panics cause of the same problem which means less testing before hitting 2.6.25 .

Thanks!
]

-->

Add the security= boot parameter. This is done to avoid LSM registration clashes in case of more than one bult-in module.

User can choose a security module to enable at boot. If no security= boot parameter is specified, only the first LSM asking for registration will be loaded. An invalid security module name will be treated as if no module has been chosen.

LSM modules must check now if they are allowed to register by calling security_module_enable(ops) first. Modify SELinux and SMACK to do so.

Signed-off-by Ahmed S. Darwish <[email protected]>
Acked-by James Morris <[email protected]>
Reported-by Alexey Dobriyan <[email protected]>

---

[James ACKed the -mm version, but this patch is exactly the same]

 Documentation/kernel-parameters.txt |    6 ++++
 include/linux/security.h            |   12 +++++++++
 security/dummy.c                    |    2 -
 security/security.c                 |   46 +++++++++++++++++++++++++++++++++++-
 security/selinux/hooks.c            |    7 +++++
 security/smack/smack_lsm.c          |    5 +++
 6 files changed, 76 insertions(+), 2 deletions(-)
Documentation/kernel-parameters.txt +6 -0
index 9a5b665..64efbdc 100644
@@ -374,6 +374,12 @@ and is between 256 and 4096 characters. It is defined in the file
 			possible to determine what the correct size should be.
 			This option provides an override for these situations.
 
+	security=	[SECURITY] Choose a security module to enable at boot. 
+			If this boot parameter is not specified, only the first 
+			security module asking for security registration will be
+			loaded. An invalid security module name will be treated
+			as if no module has been chosen.
+
 	capability.disable=
 			[SECURITY] Disable capabilities.  This would normally
 			be used only if an alternative security model is to be
include/linux/security.h +12 -0
index fe52cde..801c9ad 100644
@@ -42,6 +42,9 @@
 
 extern unsigned securebits;
 
+/* Maximum number of letters for an LSM name string */
+#define SECURITY_NAME_MAX	10
+
 struct ctl_table;
 
 /*

@@ -117,6 +120,12 @@ struct request_sock;
 /**
  * struct security_operations - main security structure
  *
+ * Security module identifier.
+ *
+ * @name:
+ *	A string that acts as a unique identifeir for the LSM with max number
+ *	of characters = SECURITY_NAME_MAX.
+ *
  * Security hooks for program execution operations.
  *
  * @bprm_alloc_security:

@@ -1207,6 +1216,8 @@ struct request_sock;
  * This is the main security structure.
  */
 struct security_operations {
+	char name[SECURITY_NAME_MAX + 1];
+
 	int (*ptrace) (struct task_struct * parent, struct task_struct * child);
 	int (*capget) (struct task_struct * target,
 		       kernel_cap_t * effective,

@@ -1466,6 +1477,7 @@ struct security_operations {
 
 /* prototypes */
 extern int security_init	(void);
+extern int security_module_enable(struct security_operations *ops);
 extern int register_security	(struct security_operations *ops);
 extern int mod_reg_security	(const char *name, struct security_operations *ops);
 extern struct dentry *securityfs_create_file(const char *name, mode_t mode,
security/dummy.c +1 -1
index 649326b..96d196f 100644
@@ -979,7 +979,7 @@ static inline int dummy_key_permission(key_ref_t key_ref,
 }
 #endif /* CONFIG_KEYS */
 
-struct security_operations dummy_security_ops;
+struct security_operations dummy_security_ops = { "dummy" };
 
 #define set_to_dummy_if_null(ops, function)				\
 	do {								\
security/security.c +45 -1

69 lines not on this page · raw message

security/selinux/hooks.c +7 -0
index 75c2e99..49709a4 100644
@@ -5219,6 +5219,8 @@ static int selinux_key_permission(key_ref_t key_ref,
 #endif
 
 static struct security_operations selinux_ops = {
+	.name =				"selinux",
+
 	.ptrace =			selinux_ptrace,
 	.capget =			selinux_capget,
 	.capset_check =			selinux_capset_check,

@@ -5405,6 +5407,11 @@ static __init int selinux_init(void)
 {
 	struct task_security_struct *tsec;
 
+	if (!security_module_enable(&selinux_ops)) {
+		selinux_enabled = 0;
+		return 0;
+	}
+
 	if (!selinux_enabled) {
 		printk(KERN_INFO "SELinux:  Disabled at boot.\n");
 		return 0;
security/smack/smack_lsm.c +5 -0
index 6fe7869..ecf1d16 100644
@@ -2436,6 +2436,8 @@ static void smack_release_secctx(char *secdata, u32 seclen)
 }
 
 static struct security_operations smack_ops = {
+	.name =				"smack",
+
 	.ptrace = 			smack_ptrace,
 	.capget = 			cap_capget,
 	.capset_check = 		cap_capset_check,

@@ -2568,6 +2570,9 @@ static struct security_operations smack_ops = {
  */
 static __init int smack_init(void)
 {
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	printk(KERN_INFO "Smack:  Initializing.\n");
 
 	/*

If you read till here, Thank you for the review ;) Regards,

Signature · 5 lines
"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com
#7 lore raw
In reply to Ahmed S. Darwish
Quoted 3 lines · Ahmed S. Darwish

Smackfs initialization without an enabled Smack leads to an early Oops that renders the system unusable.

I really think this is bogus. Global enables like this are just wrong, and a sign that something else bad is going on.

What is the oops? Why does it happen?

Linus

author
#8 lore raw

Hi Linus,

[Adding SELinux devs to CC list, please follow to the SELinux point.]

Quoted 4 lines · Linus Torvalds
Quoted 1 line · Ahmed S. Darwish
Quoted 8 lines
Quoted 2 lines

Smackfs initialization without an enabled Smack leads to an early Oops that renders the system unusable.

I really think this is bogus. Global enables like this are just wrong, and a sign that something else bad is going on.

What is the oops? Why does it happen?

The problem occurs when Smack is built-in the kernel but not chosen to register itself on boot. Smack was not chosen on boot cause either security=AnotherLSM or security=NonExistentLSM.

In all cases, init_smk_fs() ,which registers smackfs, got called cause it's an __initcall(init_smack_fs).
This include the cases where smack __was not__ chosen on boot.

Making smackfs mountable when Smack is not registered leads to:

1- an Oops by dereferncing the NULL security pointer: current->security (*)

2- Smackfs code got executed though naturally all the code assumes
that smack is already registered with the security system leading to several problems.

3- The bogus idea of having a subsystem interface available when the
subsystem itself is not available!

So the global is used in init_smk_fs to not register smackfs if Smack wasn't enabled on boot.

---- SELinux:

I think the SELinux folks faced the same problem too. In my first local iteration of the security= parameter patch, I forgot to set `selinux_disable = 1' if SELinux wasn't chosen on boot.

This led to dozen of SELinux Udev events and also led to selinuxfs being available even though SELinux hooks _weren't_ registered.

Regards,

(*)

    Could not save the oops cause it occured too early, but
    it was like this:

    __init_call
    init_smk_fs(void)
    smk_unlbl_ambient(NULL)
    /* 
     * Here: current->security = NULL, cause SMACK initial setup
     * was not executed.
     */
    smack_to_secid(current->security) 
    strncmp(.., current->security, ..)
Signature · 5 lines
"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com
author
#2 lore raw

PATCH 1/1 Security: Introduce security= boot parameter

In reply to Ahmed S. Darwish

Hi!,

[
Our usual changelog:

- Fold the SMACK bugfix here cause now it depends on the new introduced security_ symbol.
- Do not register smackfs if Smack was not loaded
- Do not use a global to check if Smack was enabled, use security_module_enable(ops) instead.
- Export smack_ops security operations to the rest of SMACK code to satisfy above point.
- Remove James ACK cause patch semantics changed (could you please reACK ?).
]

-->

Add the security= boot parameter. This is done to avoid LSM registration clashes in case of more than one bult-in module.

User can choose a security module to enable at boot. If no security= boot parameter is specified, only the first LSM asking for registration will be loaded. An invalid security module name will be treated as if no module has been chosen.

LSM modules must check now if they are allowed to register by calling security_module_enable(ops) first. Modify SELinux and SMACK to do so.

Do not let SMACK register smackfs if it was not chosen on boot. Smackfs assumes that smack hooks are registered and the initial task security setup (swapper->security) is done.

Signed-off-by Ahmed S. Darwish <[email protected]>
Reported-by Alexey Dobriyan <[email protected]>

---

 Documentation/kernel-parameters.txt |    6 ++++
 include/linux/security.h            |   12 +++++++++
 security/dummy.c                    |    2 -
 security/security.c                 |   46 +++++++++++++++++++++++++++++++++++-
 security/selinux/hooks.c            |    7 +++++
 security/smack/smack.h              |    2 +
 security/smack/smack_lsm.c          |    7 ++++-
 security/smack/smackfs.c            |    9 ++++++-
 8 files changed, 87 insertions(+), 4 deletions(-)
Documentation/kernel-parameters.txt +6 -0
index 9a5b665..64efbdc 100644
@@ -374,6 +374,12 @@ and is between 256 and 4096 characters. It is defined in the file
 			possible to determine what the correct size should be.
 			This option provides an override for these situations.
 
+	security=	[SECURITY] Choose a security module to enable at boot. 
+			If this boot parameter is not specified, only the first 
+			security module asking for security registration will be
+			loaded. An invalid security module name will be treated
+			as if no module has been chosen.
+
 	capability.disable=
 			[SECURITY] Disable capabilities.  This would normally
 			be used only if an alternative security model is to be
include/linux/security.h +12 -0
index fe52cde..801c9ad 100644
@@ -42,6 +42,9 @@
 
 extern unsigned securebits;
 
+/* Maximum number of letters for an LSM name string */
+#define SECURITY_NAME_MAX	10
+
 struct ctl_table;
 
 /*

@@ -117,6 +120,12 @@ struct request_sock;
 /**
  * struct security_operations - main security structure
  *
+ * Security module identifier.
+ *
+ * @name:
+ *	A string that acts as a unique identifeir for the LSM with max number
+ *	of characters = SECURITY_NAME_MAX.
+ *
  * Security hooks for program execution operations.
  *
  * @bprm_alloc_security:

@@ -1207,6 +1216,8 @@ struct request_sock;
  * This is the main security structure.
  */
 struct security_operations {
+	char name[SECURITY_NAME_MAX + 1];
+
 	int (*ptrace) (struct task_struct * parent, struct task_struct * child);
 	int (*capget) (struct task_struct * target,
 		       kernel_cap_t * effective,

@@ -1466,6 +1477,7 @@ struct security_operations {
 
 /* prototypes */
 extern int security_init	(void);
+extern int security_module_enable(struct security_operations *ops);
 extern int register_security	(struct security_operations *ops);
 extern int mod_reg_security	(const char *name, struct security_operations *ops);
 extern struct dentry *securityfs_create_file(const char *name, mode_t mode,
security/dummy.c +1 -1
index 649326b..96d196f 100644
@@ -979,7 +979,7 @@ static inline int dummy_key_permission(key_ref_t key_ref,
 }
 #endif /* CONFIG_KEYS */
 
-struct security_operations dummy_security_ops;
+struct security_operations dummy_security_ops = { "dummy" };
 
 #define set_to_dummy_if_null(ops, function)				\
 	do {								\
security/security.c +45 -1

69 lines not on this page · raw message

security/selinux/hooks.c +7 -0
index 75c2e99..49709a4 100644
@@ -5219,6 +5219,8 @@ static int selinux_key_permission(key_ref_t key_ref,
 #endif
 
 static struct security_operations selinux_ops = {
+	.name =				"selinux",
+
 	.ptrace =			selinux_ptrace,
 	.capget =			selinux_capget,
 	.capset_check =			selinux_capset_check,

@@ -5405,6 +5407,11 @@ static __init int selinux_init(void)
 {
 	struct task_security_struct *tsec;
 
+	if (!security_module_enable(&selinux_ops)) {
+		selinux_enabled = 0;
+		return 0;
+	}
+
 	if (!selinux_enabled) {
 		printk(KERN_INFO "SELinux:  Disabled at boot.\n");
 		return 0;
security/smack/smack.h +2 -0
index a21a0e9..c444f48 100644
@@ -15,6 +15,7 @@
 
 #include <linux/capability.h>
 #include <linux/spinlock.h>
+#include <linux/security.h>
 #include <net/netlabel.h>
 
 /*

@@ -195,6 +196,7 @@ extern struct smack_known smack_known_star;
 extern struct smack_known smack_known_unset;
 
 extern struct smk_list_entry *smack_list;
+extern struct security_operations smack_ops;
 
 /*
  * Stricly for CIPSO level manipulation.
security/smack/smack_lsm.c +6 -1
index 770eb06..afa7967 100644
@@ -2433,7 +2433,9 @@ static void smack_release_secctx(char *secdata, u32 seclen)
 {
 }
 
-static struct security_operations smack_ops = {
+struct security_operations smack_ops = {
+	.name =				"smack",
+
 	.ptrace = 			smack_ptrace,
 	.capget = 			cap_capget,
 	.capset_check = 		cap_capset_check,

@@ -2566,6 +2568,9 @@ static struct security_operations smack_ops = {
  */
 static __init int smack_init(void)
 {
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	printk(KERN_INFO "Smack:  Initializing.\n");
 
 	/*
security/smack/smackfs.c +8 -1
index 358c92c..769da9a 100644
@@ -986,12 +986,19 @@ static struct vfsmount *smackfs_mount;
  *
  * register the smackfs
  *
- * Returns 0 unless the registration fails.
+ * Do not register smackfs if Smack wasn't enabled
+ * on boot.
+ *
+ * Returns true if we were not chosen on boot or if
+ * we were chosen and filesystem registration succeeded.
  */
 static int __init init_smk_fs(void)
 {
 	int err;
 
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	err = register_filesystem(&smk_fs_type);
 	if (!err) {
 		smackfs_mount = kern_mount(&smk_fs_type);
Signature · 5 lines
"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com
maintainer
#3 lore raw

Re: [PATCH -v7 -rc3] Security: Introduce security= boot parameter

Quoted 26 lines · --- "Ahmed S. Darwish

Hi!,

[
Our usual changelog:

- Fold the SMACK bugfix here cause now it depends on the new introduced security_ symbol.
- Do not register smackfs if Smack was not loaded
- Do not use a global to check if Smack was enabled, use security_module_enable(ops) instead.
- Export smack_ops security operations to the rest of SMACK code to satisfy above point.
- Remove James ACK cause patch semantics changed (could you please reACK ?).
]

-->

Add the security= boot parameter. This is done to avoid LSM registration clashes in case of more than one bult-in module.

User can choose a security module to enable at boot. If no security= boot parameter is specified, only the first LSM asking for registration will be loaded. An invalid security module name will be treated as if no module has been chosen.

Quoted 7 lines

LSM modules must check now if they are allowed to register by calling security_module_enable(ops) first. Modify SELinux and SMACK to do so.

Do not let SMACK register smackfs if it was not chosen on boot. Smackfs assumes that smack hooks are registered and the initial task security setup (swapper->security) is done.

If the problem with initializing smackfs is because the locks aren't initialized why not leave the lock initializations in smack_init, and have them done before the check to see if the smack LSM is going to get used? Really, we're only talking about the case where a kernel is configured for testing or development purposes, and the lock initialization can't be considered a major impact in any case.

Quoted 275 lines
Signed-off-by Ahmed S. Darwish <[email protected]>
Reported-by Alexey Dobriyan <[email protected]>

---

 Documentation/kernel-parameters.txt |    6 ++++
 include/linux/security.h            |   12 +++++++++
 security/dummy.c                    |    2 -
 security/security.c                 |   46
+++++++++++++++++++++++++++++++++++-
 security/selinux/hooks.c            |    7 +++++
 security/smack/smack.h              |    2 +
 security/smack/smack_lsm.c          |    7 ++++-
 security/smack/smackfs.c            |    9 ++++++-
 8 files changed, 87 insertions(+), 4 deletions(-)
Documentation/kernel-parameters.txt +0 -0
index 9a5b665..64efbdc 100644
@@ -374,6 +374,12 @@ and is between 256 and 4096 characters. It is defined in

the file

Documentation/kernel-parameters.txt +6 -0
 			possible to determine what the correct size should be.
 			This option provides an override for these situations.
 
+	security=	[SECURITY] Choose a security module to enable at boot. 
+			If this boot parameter is not specified, only the first 
+			security module asking for security registration will be
+			loaded. An invalid security module name will be treated
+			as if no module has been chosen.
+
 	capability.disable=
 			[SECURITY] Disable capabilities.  This would normally
 			be used only if an alternative security model is to be
include/linux/security.h +12 -0
index fe52cde..801c9ad 100644
@@ -42,6 +42,9 @@
 
 extern unsigned securebits;
 
+/* Maximum number of letters for an LSM name string */
+#define SECURITY_NAME_MAX	10
+
 struct ctl_table;
 
 /*

@@ -117,6 +120,12 @@ struct request_sock;
 /**
  * struct security_operations - main security structure
  *
+ * Security module identifier.
+ *
+ * @name:
+ *	A string that acts as a unique identifeir for the LSM with max number
+ *	of characters = SECURITY_NAME_MAX.
+ *
  * Security hooks for program execution operations.
  *
  * @bprm_alloc_security:

@@ -1207,6 +1216,8 @@ struct request_sock;
  * This is the main security structure.
  */
 struct security_operations {
+	char name[SECURITY_NAME_MAX + 1];
+
 	int (*ptrace) (struct task_struct * parent, struct task_struct * child);
 	int (*capget) (struct task_struct * target,
 		       kernel_cap_t * effective,

@@ -1466,6 +1477,7 @@ struct security_operations {
 
 /* prototypes */
 extern int security_init	(void);
+extern int security_module_enable(struct security_operations *ops);
 extern int register_security	(struct security_operations *ops);
 extern int mod_reg_security	(const char *name, struct security_operations
 *ops);

extern struct dentry *securityfs_create_file(const char *name, mode_t mode,

security/dummy.c +1 -1
index 649326b..96d196f 100644
@@ -979,7 +979,7 @@ static inline int dummy_key_permission(key_ref_t key_ref,
 }
 #endif /* CONFIG_KEYS */
 
-struct security_operations dummy_security_ops;
+struct security_operations dummy_security_ops = { "dummy" };
 
 #define set_to_dummy_if_null(ops, function)				\
 	do {								\
security/security.c +45 -1
index d15e56c..f188672 100644
@@ -17,6 +17,9 @@
 #include <linux/kernel.h>
 #include <linux/security.h>
 
+/* Boot-time LSM user choice */
+static spinlock_t chosen_lsm_lock;
+static char chosen_lsm[SECURITY_NAME_MAX + 1];
 
 /* things that live in dummy.c */
 extern struct security_operations dummy_security_ops;

@@ -62,18 +65,59 @@ int __init security_init(void)
 	}
 
 	security_ops = &dummy_security_ops;
+	spin_lock_init(&chosen_lsm_lock);
 	do_security_initcalls();
 
 	return 0;
 }
 
+/* Save user chosen LSM */
+static int __init choose_lsm(char *str)
+{
+	strncpy(chosen_lsm, str, SECURITY_NAME_MAX);
+	return 1;
+}
+__setup("security=", choose_lsm);
+
+/**
+ * security_module_enable - Load given security module on boot ?
+ * @ops: a pointer to the struct security_operations that is to be checked.
+ *
+ * Each LSM must pass this method before registering its own operations
+ * to avoid security registration races.
+ *
+ * Return true if:
+ *	-The passed LSM is the one chosen by user at boot time,
+ *	-or user didsn't specify a specific LSM and we're the first to ask
+ *	 for registeration permissoin.
+ * Otherwise, return false.
+ */
+int security_module_enable(struct security_operations *ops)
+{
+	int rc = 1;
+
+	spin_lock(&chosen_lsm_lock);
+	if (!*chosen_lsm)
+		strncpy(chosen_lsm, ops->name, SECURITY_NAME_MAX);
+	else if (strncmp(ops->name, chosen_lsm, SECURITY_NAME_MAX))
+		rc = 0;
+	spin_unlock(&chosen_lsm_lock);
+
+	if (rc)
+		printk(KERN_INFO "Security: Loading '%s' security module.\n",
+		       ops->name);
+
+	return rc;
+}
+
 /**
  * register_security - registers a security framework with the kernel
  * @ops: a pointer to the struct security_options that is to be registered
  *
  * This function is to allow a security module to register itself with the
  * kernel security subsystem.  Some rudimentary checking is done on the @ops
- * value passed to this function.
+ * value passed to this function. You'll need to check first if your LSM
+ * is allowed to register its @ops by calling security_module_enable(@ops).
  *
  * If there is already a security module registered with the kernel,
  * an error will be returned.  Otherwise 0 is returned on success.
security/selinux/hooks.c +7 -0
index 75c2e99..49709a4 100644
@@ -5219,6 +5219,8 @@ static int selinux_key_permission(key_ref_t key_ref,
 #endif
 
 static struct security_operations selinux_ops = {
+	.name =				"selinux",
+
 	.ptrace =			selinux_ptrace,
 	.capget =			selinux_capget,
 	.capset_check =			selinux_capset_check,

@@ -5405,6 +5407,11 @@ static __init int selinux_init(void)
 {
 	struct task_security_struct *tsec;
 
+	if (!security_module_enable(&selinux_ops)) {
+		selinux_enabled = 0;
+		return 0;
+	}
+
 	if (!selinux_enabled) {
 		printk(KERN_INFO "SELinux:  Disabled at boot.\n");
 		return 0;
security/smack/smack.h +2 -0
index a21a0e9..c444f48 100644
@@ -15,6 +15,7 @@
 
 #include <linux/capability.h>
 #include <linux/spinlock.h>
+#include <linux/security.h>
 #include <net/netlabel.h>
 
 /*

@@ -195,6 +196,7 @@ extern struct smack_known smack_known_star;
 extern struct smack_known smack_known_unset;
 
 extern struct smk_list_entry *smack_list;
+extern struct security_operations smack_ops;
 
 /*
  * Stricly for CIPSO level manipulation.
security/smack/smack_lsm.c +3 -1
index 770eb06..afa7967 100644
@@ -2433,7 +2433,9 @@ static void smack_release_secctx(char *secdata, u32
 seclen)
 {
 }
 
-static struct security_operations smack_ops = {
+struct security_operations smack_ops = {
+	.name =				"smack",
+
 	.ptrace = 			smack_ptrace,
 	.capget = 			cap_capget,
security/smack/smack_lsm.c +3 -0
 	.capset_check = 		cap_capset_check,

@@ -2566,6 +2568,9 @@ static struct security_operations smack_ops = {
  */
 static __init int smack_init(void)
 {
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	printk(KERN_INFO "Smack:  Initializing.\n");
 
 	/*
security/smack/smackfs.c +8 -1
index 358c92c..769da9a 100644
@@ -986,12 +986,19 @@ static struct vfsmount *smackfs_mount;
  *
  * register the smackfs
  *
- * Returns 0 unless the registration fails.
+ * Do not register smackfs if Smack wasn't enabled
+ * on boot.
+ *
+ * Returns true if we were not chosen on boot or if
+ * we were chosen and filesystem registration succeeded.
  */
 static int __init init_smk_fs(void)
 {
 	int err;
 
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	err = register_filesystem(&smk_fs_type);
 	if (!err) {
 		smackfs_mount = kern_mount(&smk_fs_type);
Signature · 7 lines
-- 

"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com

Casey Schaufler
[email protected]

author
#4 lore raw

Re: [PATCH -v7 -rc3] Security: Introduce security= boot parameter

Hi Casey,

Quoted 3 lines · Casey Schaufler

--- "Ahmed S. Darwish" <[email protected]> wrote:

...

Quoted 5 lines
Quoted 4 lines

Do not let SMACK register smackfs if it was not chosen on boot. Smackfs assumes that smack hooks are registered and the initial task security setup (swapper->security) is done.

Quoted 8 lines

If the problem with initializing smackfs is because the locks aren't initialized why not leave the lock initializations in smack_init, and have them done before the check to see if the smack LSM is going to get used? Really, we're only talking about the case where a kernel is configured for testing or development purposes, and the lock initialization can't be considered a major impact in any case.

Beside the locking initialization issue, there's the current->security issue. smackfs init code code access current->security in smk_unlbl_ambient().

As you know current->security may equal Null (Oops), or point to another LSM structure that preceeded us in registration.

The locking argument can't be applied here since we may override the other LSM tsk->security pointer this time.

Ofcourse all of the above points can be handleded by various if(current->security) checks + rechecking the read/write methods of each smackfs inode, but below only two lines will fix the problem from its roots ;):

+ if (!security_module_enable(&smack_ops))
+ return 0;

Is there a problem in the current approach that I'm not aware of ?

You have your veto in this issue at the end ;)

Thank you,

Signature · 5 lines
"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com
maintainer
#5 lore raw

Re: [PATCH -v7 -rc3] Security: Introduce security= boot parameter

Quoted 39 lines · --- "Ahmed S. Darwish

Hi Casey,

Quoted 3 lines · Casey Schaufler

--- "Ahmed S. Darwish" <[email protected]> wrote:

...

Quoted 5 lines
Quoted 4 lines

Do not let SMACK register smackfs if it was not chosen on boot. Smackfs assumes that smack hooks are registered and the initial task security setup (swapper->security) is done.

Quoted 8 lines

If the problem with initializing smackfs is because the locks aren't initialized why not leave the lock initializations in smack_init, and have them done before the check to see if the smack LSM is going to get used? Really, we're only talking about the case where a kernel is configured for testing or development purposes, and the lock initialization can't be considered a major impact in any case.

Beside the locking initialization issue, there's the current->security issue. smackfs init code code access current->security in smk_unlbl_ambient().

As you know current->security may equal Null (Oops), or point to another LSM structure that preceeded us in registration.

The locking argument can't be applied here since we may override the other LSM tsk->security pointer this time.

Ofcourse all of the above points can be handleded by various if(current->security) checks + rechecking the read/write methods of each smackfs inode, but below only two lines will fix the problem from its roots ;):

(quoted diff) +2 -0
+	if (!security_module_enable(&smack_ops))
+		return 0;
Quoted 1 line

Is there a problem in the current approach that I'm not aware of ?

No, I made the common mistake of replying before I'd read all the day's threads and didn't have all the information that you did. Current LSM usage is really unfriendly to multiple "modules". I don't see any problems with your current approach now that I've dug into the issues a little further.

Quoted 1 line

You have your veto in this issue at the end ;)

I suppose, although that would be really stoopid when you're doing all the hard work. Thank you.

Casey Schaufler
[email protected]

author
#6 lore raw

PATCH 1/1 Security: Introduce security= boot parameter

In reply to Ahmed S. Darwish

Hi!,

[
v7 log:
- Fold the SMACK bugfix here cause now it depends on the new introduced security_ symbol.
- Do not register smackfs if Smack was not loaded
- Do not use a global to check if Smack was enabled, use security_module_enable(ops) instead.
- Export smack_ops security operations to the rest of SMACK code to satisfy above point.
- Remove James ACK cause patch semantics changed (could you please reACK ?).

++:
- Add in security_module_enable() comments that it may also be used to check if our LSM is enabled on boot.
- Remove the message `Security: %s is loaded, &lsm' from security_module_enable cause of its new usage in above point.
- Smack: Add a comment above init_smk_fs explaining why we can't initialize smackfs under the security_init context.
- mmm, Will we reach v10 ?
]

-->

Add the security= boot parameter. This is done to avoid LSM registration clashes in case of more than one bult-in module.

User can choose a security module to enable at boot. If no security= boot parameter is specified, only the first LSM asking for registration will be loaded. An invalid security module name will be treated as if no module has been chosen.

LSM modules must check now if they are allowed to register by calling security_module_enable(ops) first. Modify SELinux and SMACK to do so.

Do not let SMACK register smackfs if it was not chosen on boot. Smackfs assumes that smack hooks are registered and the initial task security setup (swapper->security) is done.

Signed-off-by Ahmed S. Darwish <[email protected]>
Reported-by Alexey Dobriyan <[email protected]>

---

 Documentation/kernel-parameters.txt |    6 ++++
 include/linux/security.h            |   12 +++++++++
 security/dummy.c                    |    2 -
 security/security.c                 |   46 +++++++++++++++++++++++++++++++++++-
 security/selinux/hooks.c            |    7 +++++
 security/smack/smack.h              |    2 +
 security/smack/smack_lsm.c          |    7 ++++-
 security/smack/smackfs.c            |   11 +++++++-
 8 files changed, 89 insertions(+), 4 deletions(-)
Documentation/kernel-parameters.txt +6 -0
index 9a5b665..64efbdc 100644
@@ -374,6 +374,12 @@ and is between 256 and 4096 characters. It is defined in the file
 			possible to determine what the correct size should be.
 			This option provides an override for these situations.
 
+	security=	[SECURITY] Choose a security module to enable at boot. 
+			If this boot parameter is not specified, only the first 
+			security module asking for security registration will be
+			loaded. An invalid security module name will be treated
+			as if no module has been chosen.
+
 	capability.disable=
 			[SECURITY] Disable capabilities.  This would normally
 			be used only if an alternative security model is to be
include/linux/security.h +12 -0
index fe52cde..801c9ad 100644
@@ -42,6 +42,9 @@
 
 extern unsigned securebits;
 
+/* Maximum number of letters for an LSM name string */
+#define SECURITY_NAME_MAX	10
+
 struct ctl_table;
 
 /*

@@ -117,6 +120,12 @@ struct request_sock;
 /**
  * struct security_operations - main security structure
  *
+ * Security module identifier.
+ *
+ * @name:
+ *	A string that acts as a unique identifeir for the LSM with max number
+ *	of characters = SECURITY_NAME_MAX.
+ *
  * Security hooks for program execution operations.
  *
  * @bprm_alloc_security:

@@ -1207,6 +1216,8 @@ struct request_sock;
  * This is the main security structure.
  */
 struct security_operations {
+	char name[SECURITY_NAME_MAX + 1];
+
 	int (*ptrace) (struct task_struct * parent, struct task_struct * child);
 	int (*capget) (struct task_struct * target,
 		       kernel_cap_t * effective,

@@ -1466,6 +1477,7 @@ struct security_operations {
 
 /* prototypes */
 extern int security_init	(void);
+extern int security_module_enable(struct security_operations *ops);
 extern int register_security	(struct security_operations *ops);
 extern int mod_reg_security	(const char *name, struct security_operations *ops);
 extern struct dentry *securityfs_create_file(const char *name, mode_t mode,
security/dummy.c +1 -1
index 649326b..96d196f 100644
@@ -979,7 +979,7 @@ static inline int dummy_key_permission(key_ref_t key_ref,
 }
 #endif /* CONFIG_KEYS */
 
-struct security_operations dummy_security_ops;
+struct security_operations dummy_security_ops = { "dummy" };
 
 #define set_to_dummy_if_null(ops, function)				\
 	do {								\
security/security.c +45 -1

69 lines not on this page · raw message

security/selinux/hooks.c +7 -0
index 75c2e99..49709a4 100644
@@ -5219,6 +5219,8 @@ static int selinux_key_permission(key_ref_t key_ref,
 #endif
 
 static struct security_operations selinux_ops = {
+	.name =				"selinux",
+
 	.ptrace =			selinux_ptrace,
 	.capget =			selinux_capget,
 	.capset_check =			selinux_capset_check,

@@ -5405,6 +5407,11 @@ static __init int selinux_init(void)
 {
 	struct task_security_struct *tsec;
 
+	if (!security_module_enable(&selinux_ops)) {
+		selinux_enabled = 0;
+		return 0;
+	}
+
 	if (!selinux_enabled) {
 		printk(KERN_INFO "SELinux:  Disabled at boot.\n");
 		return 0;
security/smack/smack.h +2 -0
index a21a0e9..c444f48 100644
@@ -15,6 +15,7 @@
 
 #include <linux/capability.h>
 #include <linux/spinlock.h>
+#include <linux/security.h>
 #include <net/netlabel.h>
 
 /*

@@ -195,6 +196,7 @@ extern struct smack_known smack_known_star;
 extern struct smack_known smack_known_unset;
 
 extern struct smk_list_entry *smack_list;
+extern struct security_operations smack_ops;
 
 /*
  * Stricly for CIPSO level manipulation.
security/smack/smack_lsm.c +6 -1
index 770eb06..afa7967 100644
@@ -2433,7 +2433,9 @@ static void smack_release_secctx(char *secdata, u32 seclen)
 {
 }
 
-static struct security_operations smack_ops = {
+struct security_operations smack_ops = {
+	.name =				"smack",
+
 	.ptrace = 			smack_ptrace,
 	.capget = 			cap_capget,
 	.capset_check = 		cap_capset_check,

@@ -2566,6 +2568,9 @@ static struct security_operations smack_ops = {
  */
 static __init int smack_init(void)
 {
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	printk(KERN_INFO "Smack:  Initializing.\n");
 
 	/*
security/smack/smackfs.c +10 -1
index 358c92c..effd3de 100644
@@ -986,12 +986,21 @@ static struct vfsmount *smackfs_mount;
  *
  * register the smackfs
  *
- * Returns 0 unless the registration fails.
+ * Do not register smackfs if Smack wasn't enabled
+ * on boot. We can not put this method normally under the
+ * smack_init() code path since the security subsystem get
+ * initialized before the vfs caches.
+ *
+ * Returns true if we were not chosen on boot or if
+ * we were chosen and filesystem registration succeeded.
  */
 static int __init init_smk_fs(void)
 {
 	int err;
 
+	if (!security_module_enable(&smack_ops))
+		return 0;
+
 	err = register_filesystem(&smk_fs_type);
 	if (!err) {
 		smackfs_mount = kern_mount(&smk_fs_type);

--
"Better to light a candle, than curse the darkness"

Ahmed S. Darwish
Homepage: http://darwish.07.googlepages.com
Blog: http://darwish-07.blogspot.com