Suggested-by: Stephen Smalley <sds@xxxxxxxxxxxxx>
Signed-off-by: Ondrej Mosnacek <omosnace@xxxxxxxxxx>
---
include/linux/lsm_hooks.h | 31 --
security/Kconfig | 5 -
security/apparmor/lsm.c | 6 +-
security/commoncap.c | 2 +-
security/loadpin/loadpin.c | 2 +-
security/lockdown/lockdown.c | 2 +-
security/security.c | 5 +-
security/selinux/Kconfig | 6 -
security/selinux/hooks.c | 742 ++++++++++++++++++++++++++++++-----
security/smack/smack_lsm.c | 4 +-
security/tomoyo/tomoyo.c | 6 +-
security/yama/yama_lsm.c | 2 +-
12 files changed, 654 insertions(+), 159 deletions(-)
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index 20d8cf194fb7..5064060ce910 100644
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -27,7 +27,6 @@
#include <linux/security.h>
#include <linux/init.h>
-#include <linux/rculist.h>
/**
* union security_list_options - Linux Security Module hook function list
@@ -2145,36 +2144,6 @@ extern struct lsm_info __start_early_lsm_info[], __end_early_lsm_info[];
__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
- * the security module involved. This may entail ordering the
- * module's hook list in a particular way, refusing to disable
- * the module once a policy is loaded or any number of other
- * actions better imagined than described.
- *
- * The name of the configuration option reflects the only module
- * that currently uses the mechanism. Any developer who thinks
- * disabling their module is a good idea needs to be at least as
- * careful as the SELinux team.
- */
-static inline void security_delete_hooks(struct security_hook_list *hooks,
- int count)
-{
- int i;
-
- for (i = 0; i < count; i++)
- hlist_del_rcu(&hooks[i].list);
-}
-#endif /* CONFIG_SECURITY_SELINUX_DISABLE */
-
-/* Currently required to handle SELinux runtime hook disable. */
-#ifdef CONFIG_SECURITY_WRITABLE_HOOKS
-#define __lsm_ro_after_init
-#else
-#define __lsm_ro_after_init __ro_after_init
-#endif /* CONFIG_SECURITY_WRITABLE_HOOKS */
-
extern int lsm_inode_alloc(struct inode *inode);
#endif /* ! __LINUX_LSM_HOOKS_H */
diff --git a/security/Kconfig b/security/Kconfig
index 2a1a2d396228..456764990a13 100644
--- a/security/Kconfig
+++ b/security/Kconfig
@@ -32,11 +32,6 @@ config SECURITY
If you are unsure how to answer this question, answer N.
-config SECURITY_WRITABLE_HOOKS
- depends on SECURITY
- bool
- default n
-
config SECURITYFS
bool "Enable the securityfs filesystem"
help
diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
index b621ad74f54a..cd83812a440f 100644
--- a/security/apparmor/lsm.c
+++ b/security/apparmor/lsm.c
@@ -1158,13 +1158,13 @@ static int apparmor_inet_conn_request(struct sock *sk, struct sk_buff *skb,
/*
* The cred blob is a pointer to, not an instance of, an aa_task_ctx.
*/
-struct lsm_blob_sizes apparmor_blob_sizes __lsm_ro_after_init = {
+struct lsm_blob_sizes apparmor_blob_sizes __ro_after_init = {
.lbs_cred = sizeof(struct aa_task_ctx *),
.lbs_file = sizeof(struct aa_file_ctx),
.lbs_task = sizeof(struct aa_task_ctx),
};
-static struct security_hook_list apparmor_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list apparmor_hooks[] __ro_after_init = {
LSM_HOOK_INIT(ptrace_access_check, apparmor_ptrace_access_check),
LSM_HOOK_INIT(ptrace_traceme, apparmor_ptrace_traceme),
LSM_HOOK_INIT(capget, apparmor_capget),
@@ -1368,7 +1368,7 @@ static const struct kernel_param_ops param_ops_aaintbool = {
.get = param_get_aaintbool
};
/* Boot time disable flag */
-static int apparmor_enabled __lsm_ro_after_init = 1;
+static int apparmor_enabled __ro_after_init = 1;
module_param_named(enabled, apparmor_enabled, aaintbool, 0444);
static int __init apparmor_enabled_setup(char *str)
diff --git a/security/commoncap.c b/security/commoncap.c
index f4ee0ae106b2..1471d9a5a9bc 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -1339,7 +1339,7 @@ int cap_mmap_file(struct file *file, unsigned long reqprot,
#ifdef CONFIG_SECURITY
-static struct security_hook_list capability_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list capability_hooks[] __ro_after_init = {
LSM_HOOK_INIT(capable, cap_capable),
LSM_HOOK_INIT(settime, cap_settime),
LSM_HOOK_INIT(ptrace_access_check, cap_ptrace_access_check),
diff --git a/security/loadpin/loadpin.c b/security/loadpin/loadpin.c
index ee5cb944f4ad..9bbc08bee2c0 100644
--- a/security/loadpin/loadpin.c
+++ b/security/loadpin/loadpin.c
@@ -180,7 +180,7 @@ static int loadpin_load_data(enum kernel_load_data_id id)
return loadpin_read_file(NULL, (enum kernel_read_file_id) id);
}
-static struct security_hook_list loadpin_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list loadpin_hooks[] __ro_after_init = {
LSM_HOOK_INIT(sb_free_security, loadpin_sb_free_security),
LSM_HOOK_INIT(kernel_read_file, loadpin_read_file),
LSM_HOOK_INIT(kernel_load_data, loadpin_load_data),
diff --git a/security/lockdown/lockdown.c b/security/lockdown/lockdown.c
index 5a952617a0eb..8071d0f542c8 100644
--- a/security/lockdown/lockdown.c
+++ b/security/lockdown/lockdown.c
@@ -71,7 +71,7 @@ static int lockdown_is_locked_down(enum lockdown_reason what)
return 0;
}
-static struct security_hook_list lockdown_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list lockdown_hooks[] __ro_after_init = {
LSM_HOOK_INIT(locked_down, lockdown_is_locked_down),
};
diff --git a/security/security.c b/security/security.c
index 2b5473d92416..3138a5d99813 100644
--- a/security/security.c
+++ b/security/security.c
@@ -27,6 +27,7 @@
#include <linux/backing-dev.h>
#include <linux/string.h>
#include <linux/msg.h>
+#include <linux/rculist.h>
#include <net/flow.h>
#define MAX_LSM_EVM_XATTR 2
@@ -68,14 +69,14 @@ const char *const lockdown_reasons[LOCKDOWN_CONFIDENTIALITY_MAX+1] = {
[LOCKDOWN_CONFIDENTIALITY_MAX] = "confidentiality",
};
-struct security_hook_heads security_hook_heads __lsm_ro_after_init;
+struct security_hook_heads security_hook_heads __ro_after_init;
static BLOCKING_NOTIFIER_HEAD(blocking_lsm_notifier_chain);
static struct kmem_cache *lsm_file_cache;
static struct kmem_cache *lsm_inode_cache;
char *lsm_names;
-static struct lsm_blob_sizes blob_sizes __lsm_ro_after_init;
+static struct lsm_blob_sizes blob_sizes __ro_after_init;
/* Boot-time LSM user choice */
static __initdata const char *chosen_lsm_order;
diff --git a/security/selinux/Kconfig b/security/selinux/Kconfig
index 996d35d950f7..caa5711478ad 100644
--- a/security/selinux/Kconfig
+++ b/security/selinux/Kconfig
@@ -26,7 +26,6 @@ config SECURITY_SELINUX_BOOTPARAM
config SECURITY_SELINUX_DISABLE
bool "NSA SELinux runtime disable"
depends on SECURITY_SELINUX
- select SECURITY_WRITABLE_HOOKS
default n
help
This option enables writing to a selinuxfs node 'disable', which
@@ -37,11 +36,6 @@ config SECURITY_SELINUX_DISABLE
portability across platforms where boot parameters are difficult
to employ.
- NOTE: selecting this option will disable the '__ro_after_init'
- kernel hardening feature for security hooks. Please consider
- using the selinux=0 boot parameter instead of enabling this
- option.
-
If you are unsure how to answer this question, answer N.
config SECURITY_SELINUX_DEVELOP
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 47ad4db925cf..9ac2b6b69ff9 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -650,13 +650,15 @@ static int selinux_set_mnt_opts(struct super_block *sb,
{
const struct cred *cred = current_cred();
struct superblock_security_struct *sbsec = sb->s_security;
- struct dentry *root = sbsec->sb->s_root;
struct selinux_mnt_opts *opts = mnt_opts;
struct inode_security_struct *root_isec;
u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
u32 defcontext_sid = 0;
int rc = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
mutex_lock(&sbsec->lock);
if (!selinux_initialized(&selinux_state)) {
@@ -693,7 +695,7 @@ static int selinux_set_mnt_opts(struct super_block *sb,
&& !opts)
goto out;
- root_isec = backing_inode_security_novalidate(root);
+ root_isec = backing_inode_security_novalidate(sbsec->sb->s_root);
/*
* parse the mount options, check if they are valid sids.
@@ -919,10 +921,14 @@ static int selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
int rc = 0;
const struct superblock_security_struct *oldsbsec = oldsb->s_security;
struct superblock_security_struct *newsbsec = newsb->s_security;
+ int set_fscontext, set_context, set_rootcontext;
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
- int set_fscontext = (oldsbsec->flags & FSCONTEXT_MNT);
- int set_context = (oldsbsec->flags & CONTEXT_MNT);
- int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT);
+ set_fscontext = (oldsbsec->flags & FSCONTEXT_MNT);
+ set_context = (oldsbsec->flags & CONTEXT_MNT);
+ set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT);
/*
* if the parent was able to be mounted it clearly had no special lsm
@@ -1041,6 +1047,9 @@ static int selinux_add_mnt_opt(const char *option, const char *val, int len,
int token = Opt_error;
int rc, i;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
for (i = 0; i < ARRAY_SIZE(tokens); i++) {
if (strcmp(option, tokens[i].name) == 0) {
token = tokens[i].opt;
@@ -1100,6 +1109,9 @@ static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb)
struct superblock_security_struct *sbsec = sb->s_security;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!(sbsec->flags & SE_SBINITIALIZED))
return 0;
@@ -2044,22 +2056,27 @@ static inline u32 open_file_to_av(struct file *file)
static int selinux_binder_set_context_mgr(struct task_struct *mgr)
{
- u32 mysid = current_sid();
- u32 mgrsid = task_sid(mgr);
+ if (selinux_disabled(&selinux_state))
+ return 0;
return avc_has_perm(&selinux_state,
- mysid, mgrsid, SECCLASS_BINDER,
+ current_sid(), task_sid(mgr), SECCLASS_BINDER,
BINDER__SET_CONTEXT_MGR, NULL);
}
static int selinux_binder_transaction(struct task_struct *from,
struct task_struct *to)
{
- u32 mysid = current_sid();
- u32 fromsid = task_sid(from);
- u32 tosid = task_sid(to);
+ u32 mysid, fromsid, tosid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ mysid = current_sid();
+ fromsid = task_sid(from);
+ tosid = task_sid(to);
+
if (mysid != fromsid) {
rc = avc_has_perm(&selinux_state,
mysid, fromsid, SECCLASS_BINDER,
@@ -2076,11 +2093,12 @@ static int selinux_binder_transaction(struct task_struct *from,
static int selinux_binder_transfer_binder(struct task_struct *from,
struct task_struct *to)
{
- u32 fromsid = task_sid(from);
- u32 tosid = task_sid(to);
+ if (selinux_disabled(&selinux_state))
+ return 0;
return avc_has_perm(&selinux_state,
- fromsid, tosid, SECCLASS_BINDER, BINDER__TRANSFER,
+ task_sid(from), task_sid(to),
+ SECCLASS_BINDER, BINDER__TRANSFER,
NULL);
}
@@ -2088,13 +2106,18 @@ static int selinux_binder_transfer_file(struct task_struct *from,
struct task_struct *to,
struct file *file)
{
- u32 sid = task_sid(to);
+ u32 sid;
struct file_security_struct *fsec = selinux_file(file);
struct dentry *dentry = file->f_path.dentry;
struct inode_security_struct *isec;
struct common_audit_data ad;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = task_sid(to);
+
ad.type = LSM_AUDIT_DATA_PATH;
ad.u.path = file->f_path;
@@ -2126,19 +2149,26 @@ static int selinux_binder_transfer_file(struct task_struct *from,
static int selinux_ptrace_access_check(struct task_struct *child,
unsigned int mode)
{
- u32 sid = current_sid();
- u32 csid = task_sid(child);
+ u16 cls = SECCLASS_PROCESS;
+ u32 perm = PROCESS__PTRACE;
- if (mode & PTRACE_MODE_READ)
- return avc_has_perm(&selinux_state,
- sid, csid, SECCLASS_FILE, FILE__READ, NULL);
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ if (mode & PTRACE_MODE_READ) {
+ cls = SECCLASS_FILE;
+ perm = FILE__READ;
+ }
return avc_has_perm(&selinux_state,
- sid, csid, SECCLASS_PROCESS, PROCESS__PTRACE, NULL);
+ current_sid(), task_sid(child), cls, perm, NULL);
}
static int selinux_ptrace_traceme(struct task_struct *parent)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
task_sid(parent), current_sid(), SECCLASS_PROCESS,
PROCESS__PTRACE, NULL);
@@ -2147,6 +2177,9 @@ static int selinux_ptrace_traceme(struct task_struct *parent)
static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
kernel_cap_t *inheritable, kernel_cap_t *permitted)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(target), SECCLASS_PROCESS,
PROCESS__GETCAP, NULL);
@@ -2157,6 +2190,9 @@ static int selinux_capset(struct cred *new, const struct cred *old,
const kernel_cap_t *inheritable,
const kernel_cap_t *permitted)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
cred_sid(old), cred_sid(new), SECCLASS_PROCESS,
PROCESS__SETCAP, NULL);
@@ -2175,6 +2211,9 @@ static int selinux_capset(struct cred *new, const struct cred *old,
static int selinux_capable(const struct cred *cred, struct user_namespace *ns,
int cap, unsigned int opts)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return cred_has_capability(cred, cap, opts, ns == &init_user_ns);
}
@@ -2186,6 +2225,9 @@ static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
if (!sb)
return 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmds) {
case Q_SYNC:
case Q_QUOTAON:
@@ -2210,11 +2252,17 @@ static int selinux_quota_on(struct dentry *dentry)
{
const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return dentry_has_perm(cred, dentry, FILE__QUOTAON);
}
static int selinux_syslog(int type)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (type) {
case SYSLOG_ACTION_READ_ALL: /* Read last kernel messages */
case SYSLOG_ACTION_SIZE_BUFFER: /* Return size of the log buffer */
@@ -2248,6 +2296,9 @@ static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
{
int rc, cap_sys_admin = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
rc = cred_has_capability(current_cred(), CAP_SYS_ADMIN,
CAP_OPT_NOAUDIT, true);
if (rc == 0)
@@ -2335,6 +2386,9 @@ static int selinux_bprm_set_creds(struct linux_binprm *bprm)
struct inode *inode = file_inode(bprm->file);
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
/* SELinux context only depends on initial program or script and not
* the script interpreter */
if (bprm->called_set_creds)
@@ -2505,6 +2559,9 @@ static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
struct rlimit *rlim, *initrlim;
int rc, i;
+ if (selinux_disabled(&selinux_state))
+ return;
+
new_tsec = selinux_cred(bprm->cred);
if (new_tsec->sid == new_tsec->osid)
return;
@@ -2552,6 +2609,9 @@ static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
u32 osid, sid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return;
+
osid = tsec->osid;
sid = tsec->sid;
@@ -2592,11 +2652,17 @@ static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
static int selinux_sb_alloc_security(struct super_block *sb)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return superblock_alloc_security(sb);
}
static void selinux_sb_free_security(struct super_block *sb)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
superblock_free_security(sb);
}
@@ -2622,6 +2688,9 @@ static int selinux_sb_eat_lsm_opts(char *options, void **mnt_opts)
bool first = true;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
while (1) {
int len = opt_len(from);
int token;
@@ -2682,6 +2751,9 @@ static int selinux_sb_remount(struct super_block *sb, void *mnt_opts)
u32 sid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!(sbsec->flags & SE_SBINITIALIZED))
return 0;
@@ -2732,6 +2804,9 @@ static int selinux_sb_kern_mount(struct super_block *sb)
const struct cred *cred = current_cred();
struct common_audit_data ad;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ad.type = LSM_AUDIT_DATA_DENTRY;
ad.u.dentry = sb->s_root;
return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
@@ -2742,6 +2817,9 @@ static int selinux_sb_statfs(struct dentry *dentry)
const struct cred *cred = current_cred();
struct common_audit_data ad;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ad.type = LSM_AUDIT_DATA_DENTRY;
ad.u.dentry = dentry->d_sb->s_root;
return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad);
@@ -2755,6 +2833,9 @@ static int selinux_mount(const char *dev_name,
{
const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (flags & MS_REMOUNT)
return superblock_has_perm(cred, path->dentry->d_sb,
FILESYSTEM__REMOUNT, NULL);
@@ -2766,6 +2847,9 @@ static int selinux_umount(struct vfsmount *mnt, int flags)
{
const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return superblock_has_perm(cred, mnt->mnt_sb,
FILESYSTEM__UNMOUNT, NULL);
}
@@ -2776,6 +2860,9 @@ static int selinux_fs_context_dup(struct fs_context *fc,
const struct selinux_mnt_opts *src = src_fc->security;
struct selinux_mnt_opts *opts;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!src)
return 0;
@@ -2828,6 +2915,9 @@ static int selinux_fs_context_parse_param(struct fs_context *fc,
struct fs_parse_result result;
int opt, rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
opt = fs_parse(fc, &selinux_fs_parameters, param, &result);
if (opt < 0)
return opt;
@@ -2844,11 +2934,17 @@ static int selinux_fs_context_parse_param(struct fs_context *fc,
static int selinux_inode_alloc_security(struct inode *inode)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return inode_alloc_security(inode);
}
static void selinux_inode_free_security(struct inode *inode)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
inode_free_security(inode);
}
@@ -2859,6 +2955,9 @@ static int selinux_dentry_init_security(struct dentry *dentry, int mode,
u32 newsid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
rc = selinux_determine_inode_label(selinux_cred(current_cred()),
d_inode(dentry->d_parent), name,
inode_mode_to_security_class(mode),
@@ -2879,6 +2978,9 @@ static int selinux_dentry_create_files_as(struct dentry *dentry, int mode,
int rc;
struct task_security_struct *tsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
rc = selinux_determine_inode_label(selinux_cred(old),
d_inode(dentry->d_parent), name,
inode_mode_to_security_class(mode),
@@ -2902,6 +3004,9 @@ static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
int rc;
char *context;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
sbsec = dir->i_sb->s_security;
newsid = tsec->create_sid;
@@ -2941,50 +3046,75 @@ static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
static int selinux_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_create(dir, dentry, SECCLASS_FILE);
}
static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_link(dir, old_dentry, MAY_LINK);
}
static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_link(dir, dentry, MAY_UNLINK);
}
static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_create(dir, dentry, SECCLASS_LNK_FILE);
}
static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mask)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_create(dir, dentry, SECCLASS_DIR);
}
static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_link(dir, dentry, MAY_RMDIR);
}
static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_create(dir, dentry, inode_mode_to_security_class(mode));
}
static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry,
struct inode *new_inode, struct dentry *new_dentry)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return may_rename(old_inode, old_dentry, new_inode, new_dentry);
}
static int selinux_inode_readlink(struct dentry *dentry)
{
- const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
- return dentry_has_perm(cred, dentry, FILE__READ);
+ return dentry_has_perm(current_cred(), dentry, FILE__READ);
}
static int selinux_inode_follow_link(struct dentry *dentry, struct inode *inode,
@@ -2995,6 +3125,9 @@ static int selinux_inode_follow_link(struct dentry *dentry, struct inode *inode,
struct inode_security_struct *isec;
u32 sid;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
validate_creds(cred);
ad.type = LSM_AUDIT_DATA_DENTRY;
@@ -3040,6 +3173,9 @@ static int selinux_inode_permission(struct inode *inode, int mask)
int rc, rc2;
u32 audited, denied;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
from_access = mask & MAY_ACCESS;
mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
@@ -3086,6 +3222,9 @@ static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
unsigned int ia_valid = iattr->ia_valid;
__u32 av = FILE__WRITE;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
/* ATTR_FORCE is just used for ATTR_KILL_S[UG]ID. */
if (ia_valid & ATTR_FORCE) {
ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_MODE |
@@ -3109,6 +3248,9 @@ static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
static int selinux_inode_getattr(const struct path *path)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return path_has_perm(current_cred(), path, FILE__GETATTR);
}
@@ -3131,9 +3273,12 @@ static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
struct inode_security_struct *isec;
struct superblock_security_struct *sbsec;
struct common_audit_data ad;
- u32 newsid, sid = current_sid();
+ u32 newsid, sid;
int rc = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (strcmp(name, XATTR_NAME_SELINUX)) {
rc = cap_inode_setxattr(dentry, name, value, size, flags);
if (rc)
@@ -3154,6 +3299,8 @@ static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
if (!inode_owner_or_capable(inode))
return -EPERM;
+ sid = current_sid();
+
ad.type = LSM_AUDIT_DATA_DENTRY;
ad.u.dentry = dentry;
@@ -3225,6 +3372,9 @@ static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
u32 newsid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return;
+
if (strcmp(name, XATTR_NAME_SELINUX)) {
/* Not an attribute we recognize, so nothing to do. */
return;
@@ -3260,20 +3410,25 @@ static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
static int selinux_inode_getxattr(struct dentry *dentry, const char *name)
{
- const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
- return dentry_has_perm(cred, dentry, FILE__GETATTR);
+ return dentry_has_perm(current_cred(), dentry, FILE__GETATTR);
}
static int selinux_inode_listxattr(struct dentry *dentry)
{
- const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
- return dentry_has_perm(cred, dentry, FILE__GETATTR);
+ return dentry_has_perm(current_cred(), dentry, FILE__GETATTR);
}
static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (strcmp(name, XATTR_NAME_SELINUX)) {
int rc = cap_inode_removexattr(dentry, name);
if (rc)
@@ -3297,6 +3452,9 @@ static int selinux_path_notify(const struct path *path, u64 mask,
struct common_audit_data ad;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ad.type = LSM_AUDIT_DATA_PATH;
ad.u.path = *path;
@@ -3345,6 +3503,9 @@ static int selinux_inode_getsecurity(struct inode *inode, const char *name, void
char *context = NULL;
struct inode_security_struct *isec;
+ if (selinux_disabled(&selinux_state))
+ return -EOPNOTSUPP;
+
if (strcmp(name, XATTR_SELINUX_SUFFIX))
return -EOPNOTSUPP;
@@ -3385,6 +3546,9 @@ static int selinux_inode_setsecurity(struct inode *inode, const char *name,
u32 newsid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return -EOPNOTSUPP;
+
if (strcmp(name, XATTR_SELINUX_SUFFIX))
return -EOPNOTSUPP;
@@ -3410,6 +3574,10 @@ static int selinux_inode_setsecurity(struct inode *inode, const char *name,
static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
{
const int len = sizeof(XATTR_NAME_SELINUX);
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (buffer && len <= buffer_size)
memcpy(buffer, XATTR_NAME_SELINUX, len);
return len;
@@ -3417,16 +3585,24 @@ static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t
static void selinux_inode_getsecid(struct inode *inode, u32 *secid)
{
- struct inode_security_struct *isec = inode_security_novalidate(inode);
+ struct inode_security_struct *isec;
+
+ if (selinux_disabled(&selinux_state))
+ return;
+
+ isec = inode_security_novalidate(inode);
*secid = isec->sid;
}
static int selinux_inode_copy_up(struct dentry *src, struct cred **new)
{
- u32 sid;
+ struct inode_security_struct *isec;
struct task_security_struct *tsec;
struct cred *new_creds = *new;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (new_creds == NULL) {
new_creds = prepare_creds();
if (!new_creds)
@@ -3435,14 +3611,17 @@ static int selinux_inode_copy_up(struct dentry *src, struct cred **new)
tsec = selinux_cred(new_creds);
/* Get label from overlay inode and set it in create_sid */
- selinux_inode_getsecid(d_inode(src), &sid);
- tsec->create_sid = sid;
+ isec = inode_security_novalidate(d_inode(src));
+ tsec->create_sid = isec->sid;
*new = new_creds;
return 0;
}
static int selinux_inode_copy_up_xattr(const char *name)
{
+ if (selinux_disabled(&selinux_state))
+ return -EOPNOTSUPP;
+
/* The copy_up hook above sets the initial context on an inode, but we
* don't then want to overwrite it by blindly copying all the lower
* xattrs up. Instead, we have to filter out SELinux-related xattrs.
@@ -3466,6 +3645,9 @@ static int selinux_kernfs_init_security(struct kernfs_node *kn_dir,
int rc;
char *context;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
rc = kernfs_xattr_get(kn_dir, XATTR_NAME_SELINUX, NULL, 0);
if (rc == -ENODATA)
return 0;
@@ -3537,14 +3719,16 @@ static int selinux_file_permission(struct file *file, int mask)
struct inode *inode = file_inode(file);
struct file_security_struct *fsec = selinux_file(file);
struct inode_security_struct *isec;
- u32 sid = current_sid();
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
if (!mask)
/* No permission to check. Existence test. */
return 0;
isec = inode_security(inode);
- if (sid == fsec->sid && fsec->isid == isec->sid &&
+ if (current_sid() == fsec->sid && fsec->isid == isec->sid &&
fsec->pseqno == avc_policy_seqno(&selinux_state))
/* No change since file_open check. */
return 0;
@@ -3554,6 +3738,9 @@ static int selinux_file_permission(struct file *file, int mask)
static int selinux_file_alloc_security(struct file *file)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return file_alloc_security(file);
}
@@ -3606,6 +3793,9 @@ static int selinux_file_ioctl(struct file *file, unsigned int cmd,
const struct cred *cred = current_cred();
int error = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmd) {
case FIONREAD:
/* fall through */
@@ -3692,6 +3882,9 @@ static int selinux_mmap_addr(unsigned long addr)
{
int rc = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (addr < CONFIG_LSM_MMAP_MIN_ADDR) {
u32 sid = current_sid();
rc = avc_has_perm(&selinux_state,
@@ -3708,6 +3901,9 @@ static int selinux_mmap_file(struct file *file, unsigned long reqprot,
struct common_audit_data ad;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (file) {
ad.type = LSM_AUDIT_DATA_FILE;
ad.u.file = file;
@@ -3729,7 +3925,12 @@ static int selinux_file_mprotect(struct vm_area_struct *vma,
unsigned long prot)
{
const struct cred *cred = current_cred();
- u32 sid = cred_sid(cred);
+ u32 sid;
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = cred_sid(cred);
if (selinux_state.checkreqprot)
prot = reqprot;
@@ -3768,9 +3969,10 @@ static int selinux_file_mprotect(struct vm_area_struct *vma,
static int selinux_file_lock(struct file *file, unsigned int cmd)
{
- const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
- return file_has_perm(cred, file, FILE__LOCK);
+ return file_has_perm(current_cred(), file, FILE__LOCK);
}
static int selinux_file_fcntl(struct file *file, unsigned int cmd,
@@ -3779,6 +3981,9 @@ static int selinux_file_fcntl(struct file *file, unsigned int cmd,
const struct cred *cred = current_cred();
int err = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmd) {
case F_SETFL:
if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) {
@@ -3817,6 +4022,9 @@ static void selinux_file_set_fowner(struct file *file)
{
struct file_security_struct *fsec;
+ if (selinux_disabled(&selinux_state))
+ return;
+
fsec = selinux_file(file);
fsec->fown_sid = current_sid();
}
@@ -3825,10 +4033,12 @@ static int selinux_file_send_sigiotask(struct task_struct *tsk,
struct fown_struct *fown, int signum)
{
struct file *file;
- u32 sid = task_sid(tsk);
u32 perm;
struct file_security_struct *fsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
/* struct fown_struct is never outside the context of a struct file */
file = container_of(fown, struct file, f_owner);
@@ -3840,15 +4050,16 @@ static int selinux_file_send_sigiotask(struct task_struct *tsk,
perm = signal_to_av(signum);
return avc_has_perm(&selinux_state,
- fsec->fown_sid, sid,
+ fsec->fown_sid, task_sid(tsk),
SECCLASS_PROCESS, perm, NULL);
}
static int selinux_file_receive(struct file *file)
{
- const struct cred *cred = current_cred();
+ if (selinux_disabled(&selinux_state))
+ return 0;
- return file_has_perm(cred, file, file_to_av(file));
+ return file_has_perm(current_cred(), file, file_to_av(file));
}
static int selinux_file_open(struct file *file)
@@ -3856,6 +4067,9 @@ static int selinux_file_open(struct file *file)
struct file_security_struct *fsec;
struct inode_security_struct *isec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
fsec = selinux_file(file);
isec = inode_security(file_inode(file));
/*
@@ -3883,7 +4097,12 @@ static int selinux_file_open(struct file *file)
static int selinux_task_alloc(struct task_struct *task,
unsigned long clone_flags)
{
- u32 sid = current_sid();
+ u32 sid;
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = current_sid();
return avc_has_perm(&selinux_state,
sid, sid, SECCLASS_PROCESS, PROCESS__FORK, NULL);
@@ -3898,6 +4117,9 @@ static int selinux_cred_prepare(struct cred *new, const struct cred *old,
const struct task_security_struct *old_tsec = selinux_cred(old);
struct task_security_struct *tsec = selinux_cred(new);
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
*tsec = *old_tsec;
return 0;
}
@@ -3910,11 +4132,17 @@ static void selinux_cred_transfer(struct cred *new, const struct cred *old)
const struct task_security_struct *old_tsec = selinux_cred(old);
struct task_security_struct *tsec = selinux_cred(new);
+ if (selinux_disabled(&selinux_state))
+ return;
+
*tsec = *old_tsec;
}
static void selinux_cred_getsecid(const struct cred *c, u32 *secid)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
*secid = cred_sid(c);
}
@@ -3925,11 +4153,13 @@ static void selinux_cred_getsecid(const struct cred *c, u32 *secid)
static int selinux_kernel_act_as(struct cred *new, u32 secid)
{
struct task_security_struct *tsec = selinux_cred(new);
- u32 sid = current_sid();
int ret;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ret = avc_has_perm(&selinux_state,
- sid, secid,
+ current_sid(), secid,
SECCLASS_KERNEL_SERVICE,
KERNEL_SERVICE__USE_AS_OVERRIDE,
NULL);
@@ -3950,11 +4180,13 @@ static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
{
struct inode_security_struct *isec = inode_security(inode);
struct task_security_struct *tsec = selinux_cred(new);
- u32 sid = current_sid();
int ret;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ret = avc_has_perm(&selinux_state,
- sid, isec->sid,
+ current_sid(), isec->sid,
SECCLASS_KERNEL_SERVICE,
KERNEL_SERVICE__CREATE_FILES_AS,
NULL);
@@ -3968,6 +4200,9 @@ static int selinux_kernel_module_request(char *kmod_name)
{
struct common_audit_data ad;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ad.type = LSM_AUDIT_DATA_KMOD;
ad.u.kmod_name = kmod_name;
@@ -4012,35 +4247,37 @@ static int selinux_kernel_module_from_file(struct file *file)
static int selinux_kernel_read_file(struct file *file,
enum kernel_read_file_id id)
{
- int rc = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
switch (id) {
case READING_MODULE:
- rc = selinux_kernel_module_from_file(file);
- break;
+ return selinux_kernel_module_from_file(file);
default:
break;
}
-
- return rc;
+ return 0;
}
static int selinux_kernel_load_data(enum kernel_load_data_id id)
{
- int rc = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
switch (id) {
case LOADING_MODULE:
- rc = selinux_kernel_module_from_file(NULL);
+ return selinux_kernel_module_from_file(NULL);
default:
break;
}
-
- return rc;
+ return 0;
}
static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__SETPGID, NULL);
@@ -4048,6 +4285,9 @@ static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
static int selinux_task_getpgid(struct task_struct *p)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__GETPGID, NULL);
@@ -4055,6 +4295,9 @@ static int selinux_task_getpgid(struct task_struct *p)
static int selinux_task_getsid(struct task_struct *p)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__GETSESSION, NULL);
@@ -4062,11 +4305,17 @@ static int selinux_task_getsid(struct task_struct *p)
static void selinux_task_getsecid(struct task_struct *p, u32 *secid)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
*secid = task_sid(p);
}
static int selinux_task_setnice(struct task_struct *p, int nice)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__SETSCHED, NULL);
@@ -4074,6 +4323,9 @@ static int selinux_task_setnice(struct task_struct *p, int nice)
static int selinux_task_setioprio(struct task_struct *p, int ioprio)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__SETSCHED, NULL);
@@ -4081,6 +4333,9 @@ static int selinux_task_setioprio(struct task_struct *p, int ioprio)
static int selinux_task_getioprio(struct task_struct *p)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__GETSCHED, NULL);
@@ -4091,6 +4346,9 @@ static int selinux_task_prlimit(const struct cred *cred, const struct cred *tcre
{
u32 av = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!flags)
return 0;
if (flags & LSM_PRLIMIT_WRITE)
@@ -4107,6 +4365,9 @@ static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource,
{
struct rlimit *old_rlim = p->signal->rlim + resource;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
/* Control the ability to change the hard limit (whether
lowering or raising it), so that the hard limit can
later be used as a safe reset point for the soft limit
@@ -4121,6 +4382,9 @@ static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource,
static int selinux_task_setscheduler(struct task_struct *p)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__SETSCHED, NULL);
@@ -4128,6 +4392,9 @@ static int selinux_task_setscheduler(struct task_struct *p)
static int selinux_task_getscheduler(struct task_struct *p)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__GETSCHED, NULL);
@@ -4135,6 +4402,9 @@ static int selinux_task_getscheduler(struct task_struct *p)
static int selinux_task_movememory(struct task_struct *p)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), task_sid(p), SECCLASS_PROCESS,
PROCESS__SETSCHED, NULL);
@@ -4146,6 +4416,9 @@ static int selinux_task_kill(struct task_struct *p, struct kernel_siginfo *info,
u32 secid;
u32 perm;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!sig)
perm = PROCESS__SIGNULL; /* null signal; existence test */
else
@@ -4162,11 +4435,13 @@ static void selinux_task_to_inode(struct task_struct *p,
struct inode *inode)
{
struct inode_security_struct *isec = selinux_inode(inode);
- u32 sid = task_sid(p);
+
+ if (selinux_disabled(&selinux_state))
+ return;
spin_lock(&isec->lock);
isec->sclass = inode_mode_to_security_class(inode->i_mode);
- isec->sid = sid;
+ isec->sid = task_sid(p);
isec->initialized = LABEL_INITIALIZED;
spin_unlock(&isec->lock);
}
@@ -4506,6 +4781,9 @@ static int selinux_socket_create(int family, int type,
if (kern)
return 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
secclass = socket_type_to_security_class(family, type, protocol);
rc = socket_sockcreate_sid(tsec, secclass, &newsid);
if (rc)
@@ -4525,6 +4803,9 @@ static int selinux_socket_post_create(struct socket *sock, int family,
u32 sid = SECINITSID_KERNEL;
int err = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!kern) {
err = socket_sockcreate_sid(tsec, sclass, &sid);
if (err)
@@ -4555,6 +4836,9 @@ static int selinux_socket_socketpair(struct socket *socka,
struct sk_security_struct *sksec_a = socka->sk->sk_security;
struct sk_security_struct *sksec_b = sockb->sk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
sksec_a->peer_sid = sksec_b->sid;
sksec_b->peer_sid = sksec_a->sid;
@@ -4572,6 +4856,9 @@ static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, in
u16 family;
int err;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = sock_has_perm(sk, SOCKET__BIND);
if (err)
goto out;
@@ -4796,6 +5083,9 @@ static int selinux_socket_connect(struct socket *sock,
int err;
struct sock *sk = sock->sk;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = selinux_socket_connect_helper(sock, address, addrlen);
if (err)
return err;
@@ -4805,6 +5095,9 @@ static int selinux_socket_connect(struct socket *sock,
static int selinux_socket_listen(struct socket *sock, int backlog)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__LISTEN);
}
@@ -4816,6 +5109,9 @@ static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
u16 sclass;
u32 sid;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = sock_has_perm(sock->sk, SOCKET__ACCEPT);
if (err)
return err;
@@ -4837,22 +5133,34 @@ static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
int size)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__WRITE);
}
static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
int size, int flags)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__READ);
}
static int selinux_socket_getsockname(struct socket *sock)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__GETATTR);
}
static int selinux_socket_getpeername(struct socket *sock)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__GETATTR);
}
@@ -4860,6 +5168,9 @@ static int selinux_socket_setsockopt(struct socket *sock, int level, int optname
{
int err;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = sock_has_perm(sock->sk, SOCKET__SETOPT);
if (err)
return err;
@@ -4870,11 +5181,17 @@ static int selinux_socket_setsockopt(struct socket *sock, int level, int optname
static int selinux_socket_getsockopt(struct socket *sock, int level,
int optname)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__GETOPT);
}
static int selinux_socket_shutdown(struct socket *sock, int how)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return sock_has_perm(sock->sk, SOCKET__SHUTDOWN);
}
@@ -4889,6 +5206,9 @@ static int selinux_socket_unix_stream_connect(struct sock *sock,
struct lsm_network_audit net = {0,};
int err;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ad.type = LSM_AUDIT_DATA_NET;
ad.u.net = &net;
ad.u.net->sk = other;
@@ -4921,6 +5241,9 @@ static int selinux_socket_unix_may_send(struct socket *sock,
struct common_audit_data ad;
struct lsm_network_audit net = {0,};
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ad.type = LSM_AUDIT_DATA_NET;
ad.u.net = &net;
ad.u.net->sk = other->sk;
@@ -4994,13 +5317,15 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
int err;
struct sk_security_struct *sksec = sk->sk_security;
u16 family = sk->sk_family;
- u32 sk_sid = sksec->sid;
struct common_audit_data ad;
struct lsm_network_audit net = {0,};
char *addrp;
u8 secmark_active;
u8 peerlbl_active;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (family != PF_INET && family != PF_INET6)
return 0;
@@ -5041,7 +5366,7 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
return err;
}
err = avc_has_perm(&selinux_state,
- sk_sid, peer_sid, SECCLASS_PEER,
+ sksec->sid, peer_sid, SECCLASS_PEER,
PEER__RECV, &ad);
if (err) {
selinux_netlbl_err(skb, family, err, 0);
@@ -5051,7 +5376,7 @@ static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
if (secmark_active) {
err = avc_has_perm(&selinux_state,
- sk_sid, skb->secmark, SECCLASS_PACKET,
+ sksec->sid, skb->secmark, SECCLASS_PACKET,
PACKET__RECV, &ad);
if (err)
return err;
@@ -5069,6 +5394,9 @@ static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *op
struct sk_security_struct *sksec = sock->sk->sk_security;
u32 peer_sid = SECSID_NULL;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (sksec->sclass == SECCLASS_UNIX_STREAM_SOCKET ||
sksec->sclass == SECCLASS_TCP_SOCKET ||
sksec->sclass == SECCLASS_SCTP_SOCKET)
@@ -5102,6 +5430,9 @@ static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *
u16 family;
struct inode_security_struct *isec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (skb && skb->protocol == htons(ETH_P_IP))
family = PF_INET;
else if (skb && skb->protocol == htons(ETH_P_IPV6))
@@ -5128,6 +5459,9 @@ static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority
{
struct sk_security_struct *sksec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
sksec = kzalloc(sizeof(*sksec), priority);
if (!sksec)
return -ENOMEM;
@@ -5145,6 +5479,9 @@ static void selinux_sk_free_security(struct sock *sk)
{
struct sk_security_struct *sksec = sk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
sk->sk_security = NULL;
selinux_netlbl_sk_security_free(sksec);
kfree(sksec);
@@ -5155,6 +5492,9 @@ static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
struct sk_security_struct *sksec = sk->sk_security;
struct sk_security_struct *newsksec = newsk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
newsksec->sid = sksec->sid;
newsksec->peer_sid = sksec->peer_sid;
newsksec->sclass = sksec->sclass;
@@ -5164,6 +5504,9 @@ static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
if (!sk)
*secid = SECINITSID_ANY_SOCKET;
else {
@@ -5175,10 +5518,14 @@ static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
static void selinux_sock_graft(struct sock *sk, struct socket *parent)
{
- struct inode_security_struct *isec =
- inode_security_novalidate(SOCK_INODE(parent));
+ struct inode_security_struct *isec;
struct sk_security_struct *sksec = sk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
+ isec = inode_security_novalidate(SOCK_INODE(parent));
+
if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 ||
sk->sk_family == PF_UNIX)
isec->sid = sksec->sid;
@@ -5200,6 +5547,9 @@ static int selinux_sctp_assoc_request(struct sctp_endpoint *ep,
u32 conn_sid;
int err = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!selinux_policycap_extsockclass())
return 0;
@@ -5270,6 +5620,9 @@ static int selinux_sctp_bind_connect(struct sock *sk, int optname,
struct sockaddr *addr;
struct socket *sock;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (!selinux_policycap_extsockclass())
return 0;
@@ -5346,6 +5699,9 @@ static void selinux_sctp_sk_clone(struct sctp_endpoint *ep, struct sock *sk,
struct sk_security_struct *sksec = sk->sk_security;
struct sk_security_struct *newsksec = newsk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
/* If policy does not support SECCLASS_SCTP_SOCKET then call
* the non-sctp clone version.
*/
@@ -5367,6 +5723,9 @@ static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
u32 connsid;
u32 peersid;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = selinux_skb_peerlbl_sid(skb, family, &peersid);
if (err)
return err;
@@ -5384,6 +5743,9 @@ static void selinux_inet_csk_clone(struct sock *newsk,
{
struct sk_security_struct *newsksec = newsk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
newsksec->sid = req->secid;
newsksec->peer_sid = req->peer_secid;
/* NOTE: Ideally, we should also get the isec->sid for the
@@ -5401,6 +5763,9 @@ static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
u16 family = sk->sk_family;
struct sk_security_struct *sksec = sk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
/* handle mapped IPv4 packets arriving via IPv6 sockets */
if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
family = PF_INET;
@@ -5413,6 +5778,9 @@ static int selinux_secmark_relabel_packet(u32 sid)
const struct task_security_struct *__tsec;
u32 tsid;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
__tsec = selinux_cred(current_cred());
tsid = __tsec->sid;
@@ -5423,17 +5791,26 @@ static int selinux_secmark_relabel_packet(u32 sid)
static void selinux_secmark_refcount_inc(void)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
atomic_inc(&selinux_secmark_refcount);
}
static void selinux_secmark_refcount_dec(void)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
atomic_dec(&selinux_secmark_refcount);
}
static void selinux_req_classify_flow(const struct request_sock *req,
struct flowi *fl)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
fl->flowi_secid = req->secid;
}
@@ -5441,6 +5818,9 @@ static int selinux_tun_dev_alloc_security(void **security)
{
struct tun_security_struct *tunsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
tunsec = kzalloc(sizeof(*tunsec), GFP_KERNEL);
if (!tunsec)
return -ENOMEM;
@@ -5452,12 +5832,20 @@ static int selinux_tun_dev_alloc_security(void **security)
static void selinux_tun_dev_free_security(void *security)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
kfree(security);
}
static int selinux_tun_dev_create(void)
{
- u32 sid = current_sid();
+ u32 sid;
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = current_sid();
/* we aren't taking into account the "sockcreate" SID since the socket
* that is being created here is not a socket in the traditional sense,
@@ -5475,6 +5863,9 @@ static int selinux_tun_dev_attach_queue(void *security)
{
struct tun_security_struct *tunsec = security;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return avc_has_perm(&selinux_state,
current_sid(), tunsec->sid, SECCLASS_TUN_SOCKET,
TUN_SOCKET__ATTACH_QUEUE, NULL);
@@ -5485,6 +5876,9 @@ static int selinux_tun_dev_attach(struct sock *sk, void *security)
struct tun_security_struct *tunsec = security;
struct sk_security_struct *sksec = sk->sk_security;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
/* we don't currently perform any NetLabel based labeling here and it
* isn't clear that we would want to do so anyway; while we could apply
* labeling without the support of the TUN user the resulting labeled
@@ -5501,8 +5895,13 @@ static int selinux_tun_dev_attach(struct sock *sk, void *security)
static int selinux_tun_dev_open(void *security)
{
struct tun_security_struct *tunsec = security;
- u32 sid = current_sid();
int err;
+ u32 sid;
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = current_sid();
err = avc_has_perm(&selinux_state,
sid, tunsec->sid, SECCLASS_TUN_SOCKET,
@@ -5885,6 +6284,9 @@ static unsigned int selinux_ipv6_postroute(void *priv,
static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return selinux_nlmsg_perm(sk, skb);
}
@@ -5922,6 +6324,9 @@ static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return msg_msg_alloc_security(msg);
}
@@ -5930,9 +6335,11 @@ static int selinux_msg_queue_alloc_security(struct kern_ipc_perm *msq)
{
struct ipc_security_struct *isec;
struct common_audit_data ad;
- u32 sid = current_sid();
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
isec = selinux_ipc(msq);
ipc_init_security(isec, SECCLASS_MSGQ);
@@ -5940,7 +6347,7 @@ static int selinux_msg_queue_alloc_security(struct kern_ipc_perm *msq)
ad.u.ipc_id = msq->key;
rc = avc_has_perm(&selinux_state,
- sid, isec->sid, SECCLASS_MSGQ,
+ current_sid(), isec->sid, SECCLASS_MSGQ,
MSGQ__CREATE, &ad);
return rc;
}
@@ -5949,7 +6356,9 @@ static int selinux_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg)
{
struct ipc_security_struct *isec;
struct common_audit_data ad;
- u32 sid = current_sid();
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
isec = selinux_ipc(msq);
@@ -5957,7 +6366,7 @@ static int selinux_msg_queue_associate(struct kern_ipc_perm *msq, int msqflg)
ad.u.ipc_id = msq->key;
return avc_has_perm(&selinux_state,
- sid, isec->sid, SECCLASS_MSGQ,
+ current_sid(), isec->sid, SECCLASS_MSGQ,
MSGQ__ASSOCIATE, &ad);
}
@@ -5966,6 +6375,9 @@ static int selinux_msg_queue_msgctl(struct kern_ipc_perm *msq, int cmd)
int err;
int perms;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmd) {
case IPC_INFO:
case MSG_INFO:
@@ -5997,9 +6409,14 @@ static int selinux_msg_queue_msgsnd(struct kern_ipc_perm *msq, struct msg_msg *m
struct ipc_security_struct *isec;
struct msg_security_struct *msec;
struct common_audit_data ad;
- u32 sid = current_sid();
+ u32 sid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = current_sid();
+
isec = selinux_ipc(msq);
msec = selinux_msg_msg(msg);
@@ -6045,9 +6462,14 @@ static int selinux_msg_queue_msgrcv(struct kern_ipc_perm *msq, struct msg_msg *m
struct ipc_security_struct *isec;
struct msg_security_struct *msec;
struct common_audit_data ad;
- u32 sid = task_sid(target);
+ u32 sid;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = task_sid(target);
+
isec = selinux_ipc(msq);
msec = selinux_msg_msg(msg);
@@ -6069,9 +6491,11 @@ static int selinux_shm_alloc_security(struct kern_ipc_perm *shp)
{
struct ipc_security_struct *isec;
struct common_audit_data ad;
- u32 sid = current_sid();
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
isec = selinux_ipc(shp);
ipc_init_security(isec, SECCLASS_SHM);
@@ -6079,8 +6503,8 @@ static int selinux_shm_alloc_security(struct kern_ipc_perm *shp)
ad.u.ipc_id = shp->key;
rc = avc_has_perm(&selinux_state,
- sid, isec->sid, SECCLASS_SHM,
- SHM__CREATE, &ad);
+ current_sid(), isec->sid,
+ SECCLASS_SHM, SHM__CREATE, &ad);
return rc;
}
@@ -6088,7 +6512,9 @@ static int selinux_shm_associate(struct kern_ipc_perm *shp, int shmflg)
{
struct ipc_security_struct *isec;
struct common_audit_data ad;
- u32 sid = current_sid();
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
isec = selinux_ipc(shp);
@@ -6096,8 +6522,8 @@ static int selinux_shm_associate(struct kern_ipc_perm *shp, int shmflg)
ad.u.ipc_id = shp->key;
return avc_has_perm(&selinux_state,
- sid, isec->sid, SECCLASS_SHM,
- SHM__ASSOCIATE, &ad);
+ current_sid(), isec->sid,
+ SECCLASS_SHM, SHM__ASSOCIATE, &ad);
}
/* Note, at this point, shp is locked down */
@@ -6106,6 +6532,9 @@ static int selinux_shm_shmctl(struct kern_ipc_perm *shp, int cmd)
int perms;
int err;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmd) {
case IPC_INFO:
case SHM_INFO:
@@ -6141,6 +6570,9 @@ static int selinux_shm_shmat(struct kern_ipc_perm *shp,
{
u32 perms;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (shmflg & SHM_RDONLY)
perms = SHM__READ;
else
@@ -6154,9 +6586,11 @@ static int selinux_sem_alloc_security(struct kern_ipc_perm *sma)
{
struct ipc_security_struct *isec;
struct common_audit_data ad;
- u32 sid = current_sid();
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
isec = selinux_ipc(sma);
ipc_init_security(isec, SECCLASS_SEM);
@@ -6164,8 +6598,8 @@ static int selinux_sem_alloc_security(struct kern_ipc_perm *sma)
ad.u.ipc_id = sma->key;
rc = avc_has_perm(&selinux_state,
- sid, isec->sid, SECCLASS_SEM,
- SEM__CREATE, &ad);
+ current_sid(), isec->sid,
+ SECCLASS_SEM, SEM__CREATE, &ad);
return rc;
}
@@ -6173,7 +6607,9 @@ static int selinux_sem_associate(struct kern_ipc_perm *sma, int semflg)
{
struct ipc_security_struct *isec;
struct common_audit_data ad;
- u32 sid = current_sid();
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
isec = selinux_ipc(sma);
@@ -6181,8 +6617,8 @@ static int selinux_sem_associate(struct kern_ipc_perm *sma, int semflg)
ad.u.ipc_id = sma->key;
return avc_has_perm(&selinux_state,
- sid, isec->sid, SECCLASS_SEM,
- SEM__ASSOCIATE, &ad);
+ current_sid(), isec->sid,
+ SECCLASS_SEM, SEM__ASSOCIATE, &ad);
}
/* Note, at this point, sma is locked down */
@@ -6191,6 +6627,9 @@ static int selinux_sem_semctl(struct kern_ipc_perm *sma, int cmd)
int err;
u32 perms;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmd) {
case IPC_INFO:
case SEM_INFO:
@@ -6235,6 +6674,9 @@ static int selinux_sem_semop(struct kern_ipc_perm *sma,
{
u32 perms;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (alter)
perms = SEM__READ | SEM__WRITE;
else
@@ -6247,7 +6689,9 @@ static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
{
u32 av = 0;
- av = 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (flag & S_IRUGO)
av |= IPC__UNIX_READ;
if (flag & S_IWUGO)
@@ -6261,12 +6705,17 @@ static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
{
- struct ipc_security_struct *isec = selinux_ipc(ipcp);
- *secid = isec->sid;
+ if (selinux_disabled(&selinux_state))
+ return;
+
+ *secid = selinux_ipc(ipcp)->sid;
}
static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
if (inode)
inode_doinit_with_dentry(inode, dentry);
}
@@ -6279,6 +6728,9 @@ static int selinux_getprocattr(struct task_struct *p,
int error;
unsigned len;
+ if (selinux_disabled(&selinux_state))
+ return -EINVAL;
+
rcu_read_lock();
__tsec = selinux_cred(__task_cred(p));
@@ -6325,10 +6777,15 @@ static int selinux_setprocattr(const char *name, void *value, size_t size)
{
struct task_security_struct *tsec;
struct cred *new;
- u32 mysid = current_sid(), sid = 0, ptsid;
+ u32 mysid, sid = 0, ptsid;
int error;
char *str = value;
+ if (selinux_disabled(&selinux_state))
+ return -EINVAL;
+
+ mysid = current_sid();
+
/*
* Basic control over ability to set these attributes at all.
*/
@@ -6466,17 +6923,26 @@ abort_change:
static int selinux_ismaclabel(const char *name)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return (strcmp(name, XATTR_SELINUX_SUFFIX) == 0);
}
static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
{
+ if (selinux_disabled(&selinux_state))
+ return -EOPNOTSUPP;
+
return security_sid_to_context(&selinux_state, secid,
secdata, seclen);
}
static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return security_context_to_sid(&selinux_state, secdata, seclen,
secid, GFP_KERNEL);
}
@@ -6490,6 +6956,9 @@ static void selinux_inode_invalidate_secctx(struct inode *inode)
{
struct inode_security_struct *isec = selinux_inode(inode);
+ if (selinux_disabled(&selinux_state))
+ return;
+
spin_lock(&isec->lock);
isec->initialized = LABEL_INVALID;
spin_unlock(&isec->lock);
@@ -6511,6 +6980,9 @@ static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen
*/
static int selinux_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
{
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
return __vfs_setxattr_noperm(dentry, XATTR_NAME_SELINUX, ctx, ctxlen, 0);
}
@@ -6532,6 +7004,9 @@ static int selinux_key_alloc(struct key *k, const struct cred *cred,
const struct task_security_struct *tsec;
struct key_security_struct *ksec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
if (!ksec)
return -ENOMEM;
@@ -6550,6 +7025,9 @@ static void selinux_key_free(struct key *k)
{
struct key_security_struct *ksec = k->security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
k->security = NULL;
kfree(ksec);
}
@@ -6568,6 +7046,9 @@ static int selinux_key_permission(key_ref_t key_ref,
if (perm == 0)
return 0;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
sid = cred_sid(cred);
key = key_ref_to_ptr(key_ref);
@@ -6584,6 +7065,9 @@ static int selinux_key_getsecurity(struct key *key, char **_buffer)
unsigned len;
int rc;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
rc = security_sid_to_context(&selinux_state, ksec->sid,
&context, &len);
if (!rc)
@@ -6602,6 +7086,9 @@ static int selinux_ib_pkey_access(void *ib_sec, u64 subnet_prefix, u16 pkey_val)
struct ib_security_struct *sec = ib_sec;
struct lsm_ibpkey_audit ibpkey;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = sel_ib_pkey_sid(subnet_prefix, pkey_val, &sid);
if (err)
return err;
@@ -6625,6 +7112,9 @@ static int selinux_ib_endport_manage_subnet(void *ib_sec, const char *dev_name,
struct ib_security_struct *sec = ib_sec;
struct lsm_ibendport_audit ibendport;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
err = security_ib_endport_sid(&selinux_state, dev_name, port_num,
&sid);
@@ -6645,6 +7135,9 @@ static int selinux_ib_alloc_security(void **ib_sec)
{
struct ib_security_struct *sec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
sec = kzalloc(sizeof(*sec), GFP_KERNEL);
if (!sec)
return -ENOMEM;
@@ -6656,6 +7149,9 @@ static int selinux_ib_alloc_security(void **ib_sec)
static void selinux_ib_free_security(void *ib_sec)
{
+ if (selinux_disabled(&selinux_state))
+ return;
+
kfree(ib_sec);
}
#endif
@@ -6667,6 +7163,9 @@ static int selinux_bpf(int cmd, union bpf_attr *attr,
u32 sid = current_sid();
int ret;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
switch (cmd) {
case BPF_MAP_CREATE:
ret = avc_has_perm(&selinux_state,
@@ -6734,23 +7233,27 @@ static int bpf_fd_pass(struct file *file, u32 sid)
static int selinux_bpf_map(struct bpf_map *map, fmode_t fmode)
{
- u32 sid = current_sid();
struct bpf_security_struct *bpfsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
bpfsec = map->security;
return avc_has_perm(&selinux_state,
- sid, bpfsec->sid, SECCLASS_BPF,
+ current_sid(), bpfsec->sid, SECCLASS_BPF,
bpf_map_fmode_to_av(fmode), NULL);
}
static int selinux_bpf_prog(struct bpf_prog *prog)
{
- u32 sid = current_sid();
struct bpf_security_struct *bpfsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
bpfsec = prog->aux->security;
return avc_has_perm(&selinux_state,
- sid, bpfsec->sid, SECCLASS_BPF,
+ current_sid(), bpfsec->sid, SECCLASS_BPF,
BPF__PROG_RUN, NULL);
}
@@ -6758,6 +7261,9 @@ static int selinux_bpf_map_alloc(struct bpf_map *map)
{
struct bpf_security_struct *bpfsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
bpfsec = kzalloc(sizeof(*bpfsec), GFP_KERNEL);
if (!bpfsec)
return -ENOMEM;
@@ -6772,6 +7278,9 @@ static void selinux_bpf_map_free(struct bpf_map *map)
{
struct bpf_security_struct *bpfsec = map->security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
map->security = NULL;
kfree(bpfsec);
}
@@ -6780,6 +7289,9 @@ static int selinux_bpf_prog_alloc(struct bpf_prog_aux *aux)
{
struct bpf_security_struct *bpfsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
bpfsec = kzalloc(sizeof(*bpfsec), GFP_KERNEL);
if (!bpfsec)
return -ENOMEM;
@@ -6794,6 +7306,9 @@ static void selinux_bpf_prog_free(struct bpf_prog_aux *aux)
{
struct bpf_security_struct *bpfsec = aux->security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
aux->security = NULL;
kfree(bpfsec);
}
@@ -6802,11 +7317,14 @@ static void selinux_bpf_prog_free(struct bpf_prog_aux *aux)
static int selinux_lockdown(enum lockdown_reason what)
{
struct common_audit_data ad;
- u32 sid = current_sid();
+ u32 sid;
int invalid_reason = (what <= LOCKDOWN_NONE) ||
(what == LOCKDOWN_INTEGRITY_MAX) ||
(what >= LOCKDOWN_CONFIDENTIALITY_MAX);
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
if (WARN(invalid_reason, "Invalid lockdown reason")) {
audit_log(audit_context(),
GFP_ATOMIC, AUDIT_SELINUX_ERR,
@@ -6814,6 +7332,8 @@ static int selinux_lockdown(enum lockdown_reason what)
return -EINVAL;
}
+ sid = current_sid();
+
ad.type = LSM_AUDIT_DATA_LOCKDOWN;
ad.u.reason = what;
@@ -6827,7 +7347,7 @@ static int selinux_lockdown(enum lockdown_reason what)
LOCKDOWN__CONFIDENTIALITY, &ad);
}
-struct lsm_blob_sizes selinux_blob_sizes __lsm_ro_after_init = {
+struct lsm_blob_sizes selinux_blob_sizes __ro_after_init = {
.lbs_cred = sizeof(struct task_security_struct),
.lbs_file = sizeof(struct file_security_struct),
.lbs_inode = sizeof(struct inode_security_struct),
@@ -6838,7 +7358,12 @@ struct lsm_blob_sizes selinux_blob_sizes __lsm_ro_after_init = {
#ifdef CONFIG_PERF_EVENTS
static int selinux_perf_event_open(struct perf_event_attr *attr, int type)
{
- u32 requested, sid = current_sid();
+ u32 requested, sid;
+
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ sid = current_sid();
if (type == PERF_SECURITY_OPEN)
requested = PERF_EVENT__OPEN;
@@ -6859,6 +7384,9 @@ static int selinux_perf_event_alloc(struct perf_event *event)
{
struct perf_event_security_struct *perfsec;
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
perfsec = kzalloc(sizeof(*perfsec), GFP_KERNEL);
if (!perfsec)
return -ENOMEM;
@@ -6873,6 +7401,9 @@ static void selinux_perf_event_free(struct perf_event *event)
{
struct perf_event_security_struct *perfsec = event->security;
+ if (selinux_disabled(&selinux_state))
+ return;
+
event->security = NULL;
kfree(perfsec);
}
@@ -6880,23 +7411,27 @@ static void selinux_perf_event_free(struct perf_event *event)
static int selinux_perf_event_read(struct perf_event *event)
{
struct perf_event_security_struct *perfsec = event->security;
- u32 sid = current_sid();
- return avc_has_perm(&selinux_state, sid, perfsec->sid,
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ return avc_has_perm(&selinux_state, current_sid(), perfsec->sid,
SECCLASS_PERF_EVENT, PERF_EVENT__READ, NULL);
}
static int selinux_perf_event_write(struct perf_event *event)
{
struct perf_event_security_struct *perfsec = event->security;
- u32 sid = current_sid();
- return avc_has_perm(&selinux_state, sid, perfsec->sid,
+ if (selinux_disabled(&selinux_state))
+ return 0;
+
+ return avc_has_perm(&selinux_state, current_sid(), perfsec->sid,
SECCLASS_PERF_EVENT, PERF_EVENT__WRITE, NULL);
}
#endif
-static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list selinux_hooks[] __ro_after_init = {
LSM_HOOK_INIT(binder_set_context_mgr, selinux_binder_set_context_mgr),
LSM_HOOK_INIT(binder_transaction, selinux_binder_transaction),
LSM_HOOK_INIT(binder_transfer_binder, selinux_binder_transfer_binder),
@@ -7315,18 +7850,19 @@ int selinux_disable(struct selinux_state *state)
return -EINVAL;
}
+ /*
+ * Unregister netfilter hooks (must be done before
+ * selinux_mark_disabled()).
+ */
+ selinux_nf_ip_exit();
+
selinux_mark_disabled(state);
pr_info("SELinux: Disabled at runtime.\n");
- security_delete_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks));
-
/* Try to destroy the avc node cache */
avc_disable();
- /* Unregister netfilter hooks. */
- selinux_nf_ip_exit();
-
/* Unregister selinuxfs. */
exit_sel_fs();
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index ecea41ce919b..de50c69846e0 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -4583,7 +4583,7 @@ static int smack_dentry_create_files_as(struct dentry *dentry, int mode,
return 0;
}
-struct lsm_blob_sizes smack_blob_sizes __lsm_ro_after_init = {
+struct lsm_blob_sizes smack_blob_sizes __ro_after_init = {
.lbs_cred = sizeof(struct task_smack),
.lbs_file = sizeof(struct smack_known *),
.lbs_inode = sizeof(struct inode_smack),
@@ -4591,7 +4591,7 @@ struct lsm_blob_sizes smack_blob_sizes __lsm_ro_after_init = {
.lbs_msg_msg = sizeof(struct smack_known *),
};
-static struct security_hook_list smack_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list smack_hooks[] __ro_after_init = {
LSM_HOOK_INIT(ptrace_access_check, smack_ptrace_access_check),
LSM_HOOK_INIT(ptrace_traceme, smack_ptrace_traceme),
LSM_HOOK_INIT(syslog, smack_syslog),
diff --git a/security/tomoyo/tomoyo.c b/security/tomoyo/tomoyo.c
index 716c92ec941a..9dcdef99d431 100644
--- a/security/tomoyo/tomoyo.c
+++ b/security/tomoyo/tomoyo.c
@@ -486,7 +486,7 @@ static int tomoyo_socket_sendmsg(struct socket *sock, struct msghdr *msg,
return tomoyo_socket_sendmsg_permission(sock, msg, size);
}
-struct lsm_blob_sizes tomoyo_blob_sizes __lsm_ro_after_init = {
+struct lsm_blob_sizes tomoyo_blob_sizes __ro_after_init = {
.lbs_task = sizeof(struct tomoyo_task),
};
@@ -533,7 +533,7 @@ static void tomoyo_task_free(struct task_struct *task)
* tomoyo_security_ops is a "struct security_operations" which is used for
* registering TOMOYO.
*/
-static struct security_hook_list tomoyo_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list tomoyo_hooks[] __ro_after_init = {
LSM_HOOK_INIT(cred_prepare, tomoyo_cred_prepare),
LSM_HOOK_INIT(bprm_committed_creds, tomoyo_bprm_committed_creds),
LSM_HOOK_INIT(task_alloc, tomoyo_task_alloc),
@@ -569,7 +569,7 @@ static struct security_hook_list tomoyo_hooks[] __lsm_ro_after_init = {
/* Lock for GC. */
DEFINE_SRCU(tomoyo_ss);
-int tomoyo_enabled __lsm_ro_after_init = 1;
+int tomoyo_enabled __ro_after_init = 1;
/**
* tomoyo_init - Register TOMOYO Linux as a LSM module.
diff --git a/security/yama/yama_lsm.c b/security/yama/yama_lsm.c
index 94dc346370b1..c47d4e09bfb4 100644
--- a/security/yama/yama_lsm.c
+++ b/security/yama/yama_lsm.c
@@ -421,7 +421,7 @@ static int yama_ptrace_traceme(struct task_struct *parent)
return rc;
}
-static struct security_hook_list yama_hooks[] __lsm_ro_after_init = {
+static struct security_hook_list yama_hooks[] __ro_after_init = {
LSM_HOOK_INIT(ptrace_access_check, yama_ptrace_access_check),
LSM_HOOK_INIT(ptrace_traceme, yama_ptrace_traceme),
LSM_HOOK_INIT(task_prctl, yama_task_prctl),
