cregit-Linux how code gets into the kernel

Release 4.7 security/selinux/hooks.c

Directory: security/selinux
/*
 *  NSA Security-Enhanced Linux (SELinux) security module
 *
 *  This file contains the SELinux hook function implementations.
 *
 *  Authors:  Stephen Smalley, <sds@epoch.ncsc.mil>
 *            Chris Vance, <cvance@nai.com>
 *            Wayne Salamon, <wsalamon@nai.com>
 *            James Morris <jmorris@redhat.com>
 *
 *  Copyright (C) 2001,2002 Networks Associates Technology, Inc.
 *  Copyright (C) 2003-2008 Red Hat, Inc., James Morris <jmorris@redhat.com>
 *                                         Eric Paris <eparis@redhat.com>
 *  Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
 *                          <dgoeddel@trustedcs.com>
 *  Copyright (C) 2006, 2007, 2009 Hewlett-Packard Development Company, L.P.
 *      Paul Moore <paul@paul-moore.com>
 *  Copyright (C) 2007 Hitachi Software Engineering Co., Ltd.
 *                     Yuichi Nakamura <ynakam@hitachisoft.jp>
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2,
 *      as published by the Free Software Foundation.
 */

#include <linux/init.h>
#include <linux/kd.h>
#include <linux/kernel.h>
#include <linux/tracehook.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/lsm_hooks.h>
#include <linux/xattr.h>
#include <linux/capability.h>
#include <linux/unistd.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include <linux/proc_fs.h>
#include <linux/swap.h>
#include <linux/spinlock.h>
#include <linux/syscalls.h>
#include <linux/dcache.h>
#include <linux/file.h>
#include <linux/fdtable.h>
#include <linux/namei.h>
#include <linux/mount.h>
#include <linux/netfilter_ipv4.h>
#include <linux/netfilter_ipv6.h>
#include <linux/tty.h>
#include <net/icmp.h>
#include <net/ip.h>		/* for local_port_range[] */
#include <net/tcp.h>		/* struct or_callable used in sock_rcv_skb */
#include <net/inet_connection_sock.h>
#include <net/net_namespace.h>
#include <net/netlabel.h>
#include <linux/uaccess.h>
#include <asm/ioctls.h>
#include <linux/atomic.h>
#include <linux/bitops.h>
#include <linux/interrupt.h>
#include <linux/netdevice.h>	/* for network interface checks */
#include <net/netlink.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/dccp.h>
#include <linux/quota.h>
#include <linux/un.h>		/* for Unix socket types */
#include <net/af_unix.h>	/* for Unix socket types */
#include <linux/parser.h>
#include <linux/nfs_mount.h>
#include <net/ipv6.h>
#include <linux/hugetlb.h>
#include <linux/personality.h>
#include <linux/audit.h>
#include <linux/string.h>
#include <linux/selinux.h>
#include <linux/mutex.h>
#include <linux/posix-timers.h>
#include <linux/syslog.h>
#include <linux/user_namespace.h>
#include <linux/export.h>
#include <linux/msg.h>
#include <linux/shm.h>

#include "avc.h"
#include "objsec.h"
#include "netif.h"
#include "netnode.h"
#include "netport.h"
#include "xfrm.h"
#include "netlabel.h"
#include "audit.h"
#include "avc_ss.h"

/* SECMARK reference count */

static atomic_t selinux_secmark_refcount = ATOMIC_INIT(0);

#ifdef CONFIG_SECURITY_SELINUX_DEVELOP

int selinux_enforcing;


static int __init enforcing_setup(char *str) { unsigned long enforcing; if (!kstrtoul(str, 0, &enforcing)) selinux_enforcing = enforcing ? 1 : 0; return 1; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2051.28%133.33%
eric pariseric paris1846.15%133.33%
jingoo hanjingoo han12.56%133.33%
Total39100.00%3100.00%

__setup("enforcing=", enforcing_setup); #endif #ifdef CONFIG_SECURITY_SELINUX_BOOTPARAM int selinux_enabled = CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE;
static int __init selinux_enabled_setup(char *str) { unsigned long enabled; if (!kstrtoul(str, 0, &enabled)) selinux_enabled = enabled ? 1 : 0; return 1; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2051.28%133.33%
eric pariseric paris1846.15%133.33%
jingoo hanjingoo han12.56%133.33%
Total39100.00%3100.00%

__setup("selinux=", selinux_enabled_setup); #else int selinux_enabled = 1; #endif static struct kmem_cache *sel_inode_cache; static struct kmem_cache *file_security_cache; /** * selinux_secmark_enabled - Check to see if SECMARK is currently enabled * * Description: * This function checks the SECMARK reference counter to see if any SECMARK * targets are currently configured, if the reference counter is greater than * zero SECMARK is considered to be enabled. Returns true (1) if SECMARK is * enabled, false (0) if SECMARK is disabled. If the always_check_network * policy capability is enabled, SECMARK is always considered enabled. * */
static int selinux_secmark_enabled(void) { return (selinux_policycap_alwaysnetwork || atomic_read(&selinux_secmark_refcount)); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore1473.68%150.00%
christopher j. pebenitochristopher j. pebenito526.32%150.00%
Total19100.00%2100.00%

/** * selinux_peerlbl_enabled - Check to see if peer labeling is currently enabled * * Description: * This function checks if NetLabel or labeled IPSEC is enabled. Returns true * (1) if any are enabled or false (0) if neither are enabled. If the * always_check_network policy capability is enabled, peer labeling * is always considered enabled. * */
static int selinux_peerlbl_enabled(void) { return (selinux_policycap_alwaysnetwork || netlbl_enabled() || selinux_xfrm_enabled()); }

Contributors

PersonTokensPropCommitsCommitProp
christopher j. pebenitochristopher j. pebenito1684.21%150.00%
paul moorepaul moore315.79%150.00%
Total19100.00%2100.00%


static int selinux_netcache_avc_callback(u32 event) { if (event == AVC_CALLBACK_RESET) { sel_netif_flush(); sel_netnode_flush(); sel_netport_flush(); synchronize_net(); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore32100.00%1100.00%
Total32100.00%1100.00%

/* * initialise the security for the init task */
static void cred_init_security(void) { struct cred *cred = (struct cred *) current->real_cred; struct task_security_struct *tsec; tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL); if (!tsec) panic("SELinux: Failed to initialize initial task.\n"); tsec->osid = tsec->sid = SECINITSID_KERNEL; cred->security = tsec; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4060.61%116.67%
david howellsdavid howells2537.88%466.67%
james morrisjames morris11.52%116.67%
Total66100.00%6100.00%

/* * get the security ID of a set of credentials */
static inline u32 cred_sid(const struct cred *cred) { const struct task_security_struct *tsec; tsec = cred->security; return tsec->sid; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells2066.67%266.67%
andrew mortonandrew morton1033.33%133.33%
Total30100.00%3100.00%

/* * get the objective security ID of a task */
static inline u32 task_sid(const struct task_struct *task) { u32 sid; rcu_read_lock(); sid = cred_sid(__task_cred(task)); rcu_read_unlock(); return sid; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells35100.00%2100.00%
Total35100.00%2100.00%

/* * get the subjective security ID of the current task */
static inline u32 current_sid(void) { const struct task_security_struct *tsec = current_security(); return tsec->sid; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells2191.30%133.33%
paul moorepaul moore14.35%133.33%
andrew mortonandrew morton14.35%133.33%
Total23100.00%3100.00%

/* Allocate and free functions for each kind of security blob. */
static int inode_alloc_security(struct inode *inode) { struct inode_security_struct *isec; u32 sid = current_sid(); isec = kmem_cache_zalloc(sel_inode_cache, GFP_NOFS); if (!isec) return -ENOMEM; mutex_init(&isec->lock); INIT_LIST_HEAD(&isec->list); isec->inode = inode; isec->sid = SECINITSID_UNLABELED; isec->sclass = SECCLASS_FILE; isec->task_sid = sid; inode->i_security = isec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton6876.40%116.67%
david howellsdavid howells1617.98%116.67%
eric pariseric paris22.25%116.67%
josef bacikjosef bacik11.12%116.67%
james morrisjames morris11.12%116.67%
robert p. j. dayrobert p. j. day11.12%116.67%
Total89100.00%6100.00%

static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry); /* * Try reloading inode security labels that have been marked as invalid. The * @may_sleep parameter indicates when sleeping and thus reloading labels is * allowed; when set to false, returns ERR_PTR(-ECHILD) when the label is * invalid. The @opt_dentry parameter should be set to a dentry of the inode; * when no dentry is available, set it to NULL instead. */
static int __inode_security_revalidate(struct inode *inode, struct dentry *opt_dentry, bool may_sleep) { struct inode_security_struct *isec = inode->i_security; might_sleep_if(may_sleep); if (ss_initialized && isec->initialized != LABEL_INITIALIZED) { if (!may_sleep) return -ECHILD; /* * Try reloading the inode security label. This will fail if * @opt_dentry is NULL and no dentry for this inode can be * found; in that case, continue using the old label. */ inode_doinit_with_dentry(inode, opt_dentry); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andreas gruenbacherandreas gruenbacher6193.85%133.33%
paul moorepaul moore46.15%266.67%
Total65100.00%3100.00%


static struct inode_security_struct *inode_security_novalidate(struct inode *inode) { return inode->i_security; }

Contributors

PersonTokensPropCommitsCommitProp
andreas gruenbacherandreas gruenbacher18100.00%1100.00%
Total18100.00%1100.00%


static struct inode_security_struct *inode_security_rcu(struct inode *inode, bool rcu) { int error; error = __inode_security_revalidate(inode, NULL, !rcu); if (error) return ERR_PTR(error); return inode->i_security; }

Contributors

PersonTokensPropCommitsCommitProp
andreas gruenbacherandreas gruenbacher46100.00%1100.00%
Total46100.00%1100.00%

/* * Get the security label of an inode. */
static struct inode_security_struct *inode_security(struct inode *inode) { __inode_security_revalidate(inode, NULL, true); return inode->i_security; }

Contributors

PersonTokensPropCommitsCommitProp
andreas gruenbacherandreas gruenbacher27100.00%2100.00%
Total27100.00%2100.00%


static struct inode_security_struct *backing_inode_security_novalidate(struct dentry *dentry) { struct inode *inode = d_backing_inode(dentry); return inode->i_security; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore28100.00%1100.00%
Total28100.00%1100.00%

/* * Get the security label of a dentry's backing inode. */
static struct inode_security_struct *backing_inode_security(struct dentry *dentry) { struct inode *inode = d_backing_inode(dentry); __inode_security_revalidate(inode, dentry, true); return inode->i_security; }

Contributors

PersonTokensPropCommitsCommitProp
andreas gruenbacherandreas gruenbacher37100.00%2100.00%
Total37100.00%2100.00%


static void inode_free_rcu(struct rcu_head *head) { struct inode_security_struct *isec; isec = container_of(head, struct inode_security_struct, rcu); kmem_cache_free(sel_inode_cache, isec); }

Contributors

PersonTokensPropCommitsCommitProp
steven rostedtsteven rostedt35100.00%1100.00%
Total35100.00%1100.00%


static void inode_free_security(struct inode *inode) { struct inode_security_struct *isec = inode->i_security; struct superblock_security_struct *sbsec = inode->i_sb->s_security; /* * As not all inode security structures are in a list, we check for * empty list outside of the lock to make sure that we won't waste * time taking a lock doing nothing. * * The list_del_init() function can be safely called more than once. * It should not be possible for this function to be called with * concurrent list_add(), but for better safety against future changes * in the code, we use list_empty_careful() here. */ if (!list_empty_careful(&isec->list)) { spin_lock(&sbsec->isec_lock); list_del_init(&isec->list); spin_unlock(&sbsec->isec_lock); } /* * The inode may still be referenced in a path walk and * a call to selinux_inode_permission() can be made * after inode_free_security() is called. Ideally, the VFS * wouldn't do this, but fixing that is a much harder * job. For now, simply free the i_security via RCU, and * leave the current inode->i_security pointer intact. * The inode will be freed after the RCU grace period too. */ call_rcu(&isec->rcu, inode_free_rcu); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton6176.25%250.00%
waiman longwaiman long1215.00%125.00%
steven rostedtsteven rostedt78.75%125.00%
Total80100.00%4100.00%


static int file_alloc_security(struct file *file) { struct file_security_struct *fsec; u32 sid = current_sid(); fsec = kmem_cache_zalloc(file_security_cache, GFP_KERNEL); if (!fsec) return -ENOMEM; fsec->sid = sid; fsec->fown_sid = sid; file->f_security = fsec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5285.25%125.00%
david howellsdavid howells69.84%125.00%
sangwoo parksangwoo park23.28%125.00%
stephen d. smalleystephen d. smalley11.64%125.00%
Total61100.00%4100.00%


static void file_free_security(struct file *file) { struct file_security_struct *fsec = file->f_security; file->f_security = NULL; kmem_cache_free(file_security_cache, fsec); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3090.91%150.00%
sangwoo parksangwoo park39.09%150.00%
Total33100.00%2100.00%


static int superblock_alloc_security(struct super_block *sb) { struct superblock_security_struct *sbsec; sbsec = kzalloc(sizeof(struct superblock_security_struct), GFP_KERNEL); if (!sbsec) return -ENOMEM; mutex_init(&sbsec->lock); INIT_LIST_HEAD(&sbsec->isec_head); spin_lock_init(&sbsec->isec_lock); sbsec->sb = sb; sbsec->sid = SECINITSID_UNLABELED; sbsec->def_sid = SECINITSID_FILE; sbsec->mntpoint_sid = SECINITSID_UNLABELED; sb->s_security = sbsec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton8690.53%350.00%
eric pariseric paris88.42%233.33%
james morrisjames morris11.05%116.67%
Total95100.00%6100.00%


static void superblock_free_security(struct super_block *sb) { struct superblock_security_struct *sbsec = sb->s_security; sb->s_security = NULL; kfree(sbsec); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton31100.00%1100.00%
Total31100.00%1100.00%

/* The file system's label must be initialized prior to use. */ static const char *labeling_behaviors[7] = { "uses xattr", "uses transition SIDs", "uses task SIDs", "uses genfs_contexts", "not configured for labeling", "uses mountpoint labeling", "uses native labeling", };
static inline int inode_doinit(struct inode *inode) { return inode_doinit_with_dentry(inode, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton20100.00%1100.00%
Total20100.00%1100.00%

enum { Opt_error = -1, Opt_context = 1, Opt_fscontext = 2, Opt_defcontext = 3, Opt_rootcontext = 4, Opt_labelsupport = 5, Opt_nextmntopt = 6, }; #define NUM_SEL_MNT_OPTS (Opt_nextmntopt - 1) static const match_table_t tokens = { {Opt_context, CONTEXT_STR "%s"}, {Opt_fscontext, FSCONTEXT_STR "%s"}, {Opt_defcontext, DEFCONTEXT_STR "%s"}, {Opt_rootcontext, ROOTCONTEXT_STR "%s"}, {Opt_labelsupport, LABELSUPP_STR}, {Opt_error, NULL}, }; #define SEL_MOUNT_FAIL_MSG "SELinux: duplicate or incompatible mount options\n"
static int may_context_mount_sb_relabel(u32 sid, struct superblock_security_struct *sbsec, const struct cred *cred) { const struct task_security_struct *tsec = cred->security; int rc; rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM, FILESYSTEM__RELABELFROM, NULL); if (rc) return rc; rc = avc_has_perm(tsec->sid, sid, SECCLASS_FILESYSTEM, FILESYSTEM__RELABELTO, NULL); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris6683.54%150.00%
david howellsdavid howells1316.46%150.00%
Total79100.00%2100.00%


static int may_context_mount_inode_relabel(u32 sid, struct superblock_security_struct *sbsec, const struct cred *cred) { const struct task_security_struct *tsec = cred->security; int rc; rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM, FILESYSTEM__RELABELFROM, NULL); if (rc) return rc; rc = avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM, FILESYSTEM__ASSOCIATE, NULL); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris6683.54%150.00%
david howellsdavid howells1316.46%150.00%
Total79100.00%2100.00%


static int selinux_is_sblabel_mnt(struct super_block *sb) { struct superblock_security_struct *sbsec = sb->s_security; return sbsec->behavior == SECURITY_FS_USE_XATTR || sbsec->behavior == SECURITY_FS_USE_TRANS || sbsec->behavior == SECURITY_FS_USE_TASK || sbsec->behavior == SECURITY_FS_USE_NATIVE || /* Special handling. Genfs but also in-core setxattr handler */ !strcmp(sb->s_type->name, "sysfs") || !strcmp(sb->s_type->name, "pstore") || !strcmp(sb->s_type->name, "debugfs") || !strcmp(sb->s_type->name, "rootfs"); }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris5861.70%133.33%
mark salyzynmark salyzyn3031.91%133.33%
j. bruce fieldsj. bruce fields66.38%133.33%
Total94100.00%3100.00%


static int sb_finish_set_opts(struct super_block *sb) { struct superblock_security_struct *sbsec = sb->s_security; struct dentry *root = sb->s_root; struct inode *root_inode = d_backing_inode(root); int rc = 0; if (sbsec->behavior == SECURITY_FS_USE_XATTR) { /* Make sure that the xattr handler exists and that no error other than -ENODATA is returned by getxattr on the root directory. -ENODATA is ok, as this may be the first boot of the SELinux kernel before we have assigned xattr values to the filesystem. */ if (!root_inode->i_op->getxattr) { printk(KERN_WARNING "SELinux: (dev %s, type %s) has no " "xattr support\n", sb->s_id, sb->s_type->name); rc = -EOPNOTSUPP; goto out; } rc = root_inode->i_op->getxattr(root, root_inode, XATTR_NAME_SELINUX, NULL, 0); if (rc < 0 && rc != -ENODATA) { if (rc == -EOPNOTSUPP) printk(KERN_WARNING "SELinux: (dev %s, type " "%s) has no security xattr handler\n", sb->s_id, sb->s_type->name); else printk(KERN_WARNING "SELinux: (dev %s, type " "%s) getxattr errno %d\n", sb->s_id, sb->s_type->name, -rc); goto out; } } if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors)) printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n", sb->s_id, sb->s_type->name); sbsec->flags |= SE_SBINITIALIZED; if (selinux_is_sblabel_mnt(sb)) sbsec->flags |= SBLABEL_MNT; /* Initialize the root inode. */ rc = inode_doinit_with_dentry(root_inode, root); /* Initialize any other inodes associated with the superblock, e.g. inodes created prior to initial policy load or inodes created during get_sb by a pseudo filesystem that directly populates itself. */ spin_lock(&sbsec->isec_lock); next_inode: if (!list_empty(&sbsec->isec_head)) { struct inode_security_struct *isec = list_entry(sbsec->isec_head.next, struct inode_security_struct, list); struct inode *inode = isec->inode; list_del_init(&isec->list); spin_unlock(&sbsec->isec_lock); inode = igrab(inode); if (inode) { if (!IS_PRIVATE(inode)) inode_doinit(inode); iput(inode); } spin_lock(&sbsec->isec_lock); goto next_inode; } spin_unlock(&sbsec->isec_lock); out: return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris24770.57%430.77%
andrew mortonandrew morton5515.71%323.08%
linus torvaldslinus torvalds205.71%17.69%
david p. quigleydavid p. quigley154.29%215.38%
stephen d. smalleystephen d. smalley82.29%17.69%
david howellsdavid howells30.86%17.69%
al viroal viro20.57%17.69%
Total350100.00%13100.00%

/* * This function should allow an FS to ask what it's mount security * options were so it can use those later for submounts, displaying * mount options, or whatever. */
static int selinux_get_mnt_opts(const struct super_block *sb, struct security_mnt_opts *opts) { int rc = 0, i; struct superblock_security_struct *sbsec = sb->s_security; char *context = NULL; u32 len; char tmp; security_init_mnt_opts(opts); if (!(sbsec->flags & SE_SBINITIALIZED)) return -EINVAL; if (!ss_initialized) return -EINVAL; /* make sure we always check enough bits to cover the mask */ BUILD_BUG_ON(SE_MNTMASK >= (1 << NUM_SEL_MNT_OPTS)); tmp = sbsec->flags & SE_MNTMASK; /* count the number of mount options for this sb */ for (i = 0; i < NUM_SEL_MNT_OPTS; i++) { if (tmp & 0x01) opts->num_mnt_opts++; tmp >>= 1; } /* Check if the Label support flag is set */ if (sbsec->flags & SBLABEL_MNT) opts->num_mnt_opts++; opts->mnt_opts = kcalloc(opts->num_mnt_opts, sizeof(char *), GFP_ATOMIC); if (!opts->mnt_opts) { rc = -ENOMEM; goto out_free; } opts->mnt_opts_flags = kcalloc(opts->num_mnt_opts, sizeof(int), GFP_ATOMIC); if (!opts->mnt_opts_flags) { rc = -ENOMEM; goto out_free; } i = 0; if (sbsec->flags & FSCONTEXT_MNT) { rc = security_sid_to_context(sbsec->sid, &context, &len); if (rc) goto out_free; opts->mnt_opts[i] = context; opts->mnt_opts_flags[i++] = FSCONTEXT_MNT; } if (sbsec->flags & CONTEXT_MNT) { rc = security_sid_to_context(sbsec->mntpoint_sid, &context, &len); if (rc) goto out_free; opts->mnt_opts[i] = context; opts->mnt_opts_flags[i++] = CONTEXT_MNT; } if (sbsec->flags & DEFCONTEXT_MNT) { rc = security_sid_to_context(sbsec->def_sid, &context, &len); if (rc) goto out_free; opts->mnt_opts[i] = context; opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT; } if (sbsec->flags & ROOTCONTEXT_MNT) { struct dentry *root = sbsec->sb->s_root; struct inode_security_struct *isec = backing_inode_security(root); rc = security_sid_to_context(isec->sid, &context, &len); if (rc) goto out_free; opts->mnt_opts[i] = context; opts->mnt_opts_flags[i++] = ROOTCONTEXT_MNT; } if (sbsec->flags & SBLABEL_MNT) { opts->mnt_opts[i] = NULL; opts->mnt_opts_flags[i++] = SBLABEL_MNT; } BUG_ON(i != opts->num_mnt_opts); return 0; out_free: security_free_mnt_opts(opts); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris43989.59%562.50%
david p. quigleydavid p. quigley479.59%225.00%
andreas gruenbacherandreas gruenbacher40.82%112.50%
Total490100.00%8100.00%


static int bad_option(struct superblock_security_struct *sbsec, char flag, u32 old_sid, u32 new_sid) { char mnt_flags = sbsec->flags & SE_MNTMASK; /* check if the old mount command had the same options */ if (sbsec->flags & SE_SBINITIALIZED) if (!(sbsec->flags & flag) || (old_sid != new_sid)) return 1; /* check if we were passed the same options twice, * aka someone passed context=a,context=b */ if (!(sbsec->flags & SE_SBINITIALIZED)) if (mnt_flags & flag) return 1; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris6478.05%150.00%
david p. quigleydavid p. quigley1821.95%150.00%
Total82100.00%2100.00%

/* * Allow filesystems with binary mount data to explicitly set mount point * labeling information. */
static int selinux_set_mnt_opts(struct super_block *sb, struct security_mnt_opts *opts, unsigned long kern_flags, unsigned long *set_kern_flags) { const struct cred *cred = current_cred(); int rc = 0, i; struct superblock_security_struct *sbsec = sb->s_security; const char *name = sb->s_type->name; struct dentry *root = sbsec->sb->s_root; struct inode_security_struct *root_isec; u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0; u32 defcontext_sid = 0; char **mount_options = opts->mnt_opts; int *flags = opts->mnt_opts_flags; int num_opts = opts->num_mnt_opts; mutex_lock(&sbsec->lock); if (!ss_initialized) { if (!num_opts) { /* Defer initialization until selinux_complete_init, after the initial policy is loaded and the security server is ready to handle calls. */ goto out; } rc = -EINVAL; printk(KERN_WARNING "SELinux: Unable to set superblock options " "before the security server is initialized\n"); goto out; } if (kern_flags && !set_kern_flags) { /* Specifying internal flags without providing a place to * place the results is not allowed */ rc = -EINVAL; goto out; } /* * Binary mount data FS will come through this function twice. Once * from an explicit call and once from the generic calls from the vfs. * Since the generic VFS calls will not contain any security mount data * we need to skip the double mount verification. * * This does open a hole in which we will not notice if the first * mount using this sb set explict options and a second mount using * this sb does not set any security options. (The first options * will be used for both mounts) */ if ((sbsec->flags & SE_SBINITIALIZED) && (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA) && (num_opts == 0)) goto out; root_isec = backing_inode_security_novalidate(root); /* * parse the mount options, check if they are valid sids. * also check if someone is trying to mount the same sb more * than once with different security options. */ for (i = 0; i < num_opts; i++) { u32 sid; if (flags[i] == SBLABEL_MNT) continue; rc = security_context_str_to_sid(mount_options[i], &sid, GFP_KERNEL); if (rc) { printk(KERN_WARNING "SELinux: security_context_str_to_sid" "(%s) failed for (dev %s, type %s) errno=%d\n", mount_options[i], sb->s_id, name, rc); goto out; } switch (flags[i]) { case FSCONTEXT_MNT: fscontext_sid = sid; if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid, fscontext_sid)) goto out_double_mount; sbsec->flags |= FSCONTEXT_MNT; break; case CONTEXT_MNT: context_sid = sid; if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid, context_sid)) goto out_double_mount; sbsec->flags |= CONTEXT_MNT; break; case ROOTCONTEXT_MNT: rootcontext_sid = sid; if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, rootcontext_sid)) goto out_double_mount; sbsec->flags |= ROOTCONTEXT_MNT; break; case DEFCONTEXT_MNT: defcontext_sid = sid; if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid, defcontext_sid)) goto out_double_mount; sbsec->flags |= DEFCONTEXT_MNT; break; default: rc = -EINVAL; goto out; } } if (sbsec->flags & SE_SBINITIALIZED) { /* previously mounted with options, but not on this attempt? */ if ((sbsec->flags & SE_MNTMASK) && !num_opts) goto out_double_mount; rc = 0; goto out; } if (strcmp(sb->s_type->name, "proc") == 0) sbsec->flags |= SE_SBPROC | SE_SBGENFS; if (!strcmp(sb->s_type->name, "debugfs") || !strcmp(sb->s_type->name, "sysfs") || !strcmp(sb->s_type->name, "pstore")) sbsec->flags |= SE_SBGENFS; if (!sbsec->behavior) { /* * Determine the labeling behavior to use for this * filesystem type. */ rc = security_fs_use(sb); if (rc) { printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n", __func__, sb->s_type->name, rc); goto out; } } /* sets the context of the superblock for the fs being mounted. */ if (fscontext_sid) { rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, cred); if (rc) goto out; sbsec->sid = fscontext_sid; } /* * Switch to using mount point labeling behavior. * sets the label used on all file below the mountpoint, and will set * the superblock context if not already set. */ if (kern_flags & SECURITY_LSM_NATIVE_LABELS && !context_sid) { sbsec->behavior = SECURITY_FS_USE_NATIVE; *set_kern_flags |= SECURITY_LSM_NATIVE_LABELS; } if (context_sid) { if (!fscontext_sid) { rc = may_context_mount_sb_relabel(context_sid, sbsec, cred); if (rc) goto out; sbsec->sid = context_sid; } else { rc = may_context_mount_inode_relabel(context_sid, sbsec, cred); if (rc) goto out; } if (!rootcontext_sid) rootcontext_sid = context_sid; sbsec->mntpoint_sid = context_sid; sbsec->behavior = SECURITY_FS_USE_MNTPOINT; } if (rootcontext_sid) { rc = may_context_mount_inode_relabel(rootcontext_sid, sbsec, cred); if (rc) goto out; root_isec->sid = rootcontext_sid; root_isec->initialized = LABEL_INITIALIZED; } if (defcontext_sid) { if (sbsec->behavior != SECURITY_FS_USE_XATTR && sbsec->behavior != SECURITY_FS_USE_NATIVE) { rc = -EINVAL; printk(KERN_WARNING "SELinux: defcontext option is " "invalid for this filesystem type\n"); goto out; } if (defcontext_sid != sbsec->def_sid) { rc = may_context_mount_inode_relabel(defcontext_sid, sbsec, cred); if (rc) goto out; } sbsec->def_sid = defcontext_sid; } rc = sb_finish_set_opts(sb); out: mutex_unlock(&sbsec->lock); return rc; out_double_mount: rc = -EINVAL; printk(KERN_WARNING "SELinux: mount invalid. Same superblock, different " "security settings for (dev %s, type %s)\n", sb->s_id, name); goto out; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris55464.42%623.08%
andrew mortonandrew morton11513.37%415.38%
david quigleydavid quigley657.56%27.69%
stephen d. smalleystephen d. smalley465.35%27.69%
david p. quigleydavid p. quigley242.79%27.69%
linus torvaldslinus torvalds151.74%13.85%
david howellsdavid howells141.63%13.85%
james morrisjames morris111.28%13.85%
paul moorepaul moore70.81%13.85%
andreas gruenbacherandreas gruenbacher30.35%27.69%
rasmus villemoesrasmus villemoes20.23%13.85%
nikolay aleksandrovnikolay aleksandrov20.23%13.85%
adrian bunkadrian bunk10.12%13.85%
harvey harrisonharvey harrison10.12%13.85%
Total860100.00%26100.00%


static int selinux_cmp_sb_context(const struct super_block *oldsb, const struct super_block *newsb) { struct superblock_security_struct *old = oldsb->s_security; struct superblock_security_struct *new = newsb->s_security; char oldflags = old->flags & SE_MNTMASK; char newflags = new->flags & SE_MNTMASK; if (oldflags != newflags) goto mismatch; if ((oldflags & FSCONTEXT_MNT) && old->sid != new->sid) goto mismatch; if ((oldflags & CONTEXT_MNT) && old->mntpoint_sid != new->mntpoint_sid) goto mismatch; if ((oldflags & DEFCONTEXT_MNT) && old->def_sid != new->def_sid) goto mismatch; if (oldflags & ROOTCONTEXT_MNT) { struct inode_security_struct *oldroot = backing_inode_security(oldsb->s_root); struct inode_security_struct *newroot = backing_inode_security(newsb->s_root); if (oldroot->sid != newroot->sid) goto mismatch; } return 0; mismatch: printk(KERN_WARNING "SELinux: mount invalid. Same superblock, " "different security settings for (dev %s, " "type %s)\n", newsb->s_id, newsb->s_type->name); return -EBUSY; }

Contributors

PersonTokensPropCommitsCommitProp
jeff laytonjeff layton18696.88%133.33%
david howellsdavid howells42.08%133.33%
andreas gruenbacherandreas gruenbacher21.04%133.33%
Total192100.00%3100.00%


static int selinux_sb_clone_mnt_opts(const struct super_block *oldsb, struct super_block *newsb) { const struct superblock_security_struct *oldsbsec = oldsb->s_security; struct superblock_security_struct *newsbsec = newsb->s_security; int set_fscontext = (oldsbsec->flags & FSCONTEXT_MNT); int set_context = (oldsbsec->flags & CONTEXT_MNT); int set_rootcontext = (oldsbsec->flags & ROOTCONTEXT_MNT); /* * if the parent was able to be mounted it clearly had no special lsm * mount options. thus we can safely deal with this superblock later */ if (!ss_initialized) return 0; /* how can we clone if the old one wasn't set up?? */ BUG_ON(!(oldsbsec->flags & SE_SBINITIALIZED)); /* if fs is reusing a sb, make sure that the contexts match */ if (newsbsec->flags & SE_SBINITIALIZED) return selinux_cmp_sb_context(oldsb, newsb); mutex_lock(&newsbsec->lock); newsbsec->flags = oldsbsec->flags; newsbsec->sid = oldsbsec->sid; newsbsec->def_sid = oldsbsec->def_sid; newsbsec->behavior = oldsbsec->behavior; if (set_context) { u32 sid = oldsbsec->mntpoint_sid; if (!set_fscontext) newsbsec->sid = sid; if (!set_rootcontext) { struct inode_security_struct *newisec = backing_inode_security(newsb->s_root); newisec->sid = sid; } newsbsec->mntpoint_sid = sid; } if (set_rootcontext) { const struct inode_security_struct *oldisec = backing_inode_security(oldsb->s_root); struct inode_security_struct *newisec = backing_inode_security(newsb->s_root); newisec->sid = oldisec->sid; } sb_finish_set_opts(newsb); mutex_unlock(&newsbsec->lock); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris20177.91%650.00%
andrew mortonandrew morton186.98%18.33%
jeff laytonjeff layton166.20%18.33%
david p. quigleydavid p. quigley83.10%18.33%
andreas gruenbacherandreas gruenbacher83.10%18.33%
david howellsdavid howells62.33%18.33%
al viroal viro10.39%18.33%
Total258100.00%12100.00%


static int selinux_parse_opts_str(char *options, struct security_mnt_opts *opts) { char *p; char *context = NULL, *defcontext = NULL; char *fscontext = NULL, *rootcontext = NULL; int rc, num_mnt_opts = 0; opts->num_mnt_opts = 0; /* Standard string-based options. */ while ((p = strsep(&options, "|")) != NULL) { int token; substring_t args[MAX_OPT_ARGS]; if (!*p) continue; token = match_token(p, tokens, args); switch (token) { case Opt_context: if (context || defcontext) { rc = -EINVAL; printk(KERN_WARNING SEL_MOUNT_FAIL_MSG); goto out_err; } context = match_strdup(&args[0]); if (!context) { rc = -ENOMEM; goto out_err; } break; case Opt_fscontext: if (fscontext) { rc = -EINVAL; printk(KERN_WARNING SEL_MOUNT_FAIL_MSG); goto out_err; } fscontext = match_strdup(&args[0]); if (!fscontext) { rc = -ENOMEM; goto out_err; } break; case Opt_rootcontext: if (rootcontext) { rc = -EINVAL; printk(KERN_WARNING SEL_MOUNT_FAIL_MSG); goto out_err; } rootcontext = match_strdup(&args[0]); if (!rootcontext) { rc = -ENOMEM; goto out_err; } break; case Opt_defcontext: if (context || defcontext) { rc = -EINVAL; printk(KERN_WARNING SEL_MOUNT_FAIL_MSG); goto out_err; } defcontext = match_strdup(&args[0]); if (!defcontext) { rc = -ENOMEM; goto out_err; } break; case Opt_labelsupport: break; default: rc = -EINVAL; printk(KERN_WARNING "SELinux: unknown mount option\n"); goto out_err; } } rc = -ENOMEM; opts->mnt_opts = kcalloc(NUM_SEL_MNT_OPTS, sizeof(char *), GFP_ATOMIC); if (!opts->mnt_opts) goto out_err; opts->mnt_opts_flags = kcalloc(NUM_SEL_MNT_OPTS, sizeof(int), GFP_ATOMIC); if (!opts->mnt_opts_flags) { kfree(opts->mnt_opts); goto out_err; } if (fscontext) { opts->mnt_opts[num_mnt_opts] = fscontext; opts->mnt_opts_flags[num_mnt_opts++] = FSCONTEXT_MNT; } if (context) { opts->mnt_opts[num_mnt_opts] = context; opts->mnt_opts_flags[num_mnt_opts++] = CONTEXT_MNT; } if (rootcontext) { opts->mnt_opts[num_mnt_opts] = rootcontext; opts->mnt_opts_flags[num_mnt_opts++] = ROOTCONTEXT_MNT; } if (defcontext) { opts->mnt_opts[num_mnt_opts] = defcontext; opts->mnt_opts_flags[num_mnt_opts++] = DEFCONTEXT_MNT; } opts->num_mnt_opts = num_mnt_opts; return 0; out_err: kfree(context); kfree(defcontext); kfree(fscontext); kfree(rootcontext); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris39875.67%240.00%
andrew mortonandrew morton12323.38%120.00%
david p. quigleydavid p. quigley40.76%120.00%
adrian bunkadrian bunk10.19%120.00%
Total526100.00%5100.00%

/* * string mount options parsing and call set the sbsec */
static int superblock_doinit(struct super_block *sb, void *data) { int rc = 0; char *options = data; struct security_mnt_opts opts; security_init_mnt_opts(&opts); if (!data) goto out; BUG_ON(sb->s_type->fs_flags & FS_BINARY_MOUNTDATA); rc = selinux_parse_opts_str(options, &opts); if (rc) goto out_err; out: rc = selinux_set_mnt_opts(sb, &opts, 0, NULL); out_err: security_free_mnt_opts(&opts); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris9595.96%150.00%
david quigleydavid quigley44.04%150.00%
Total99100.00%2100.00%


static void selinux_write_opts(struct seq_file *m, struct security_mnt_opts *opts) { int i; char *prefix; for (i = 0; i < opts->num_mnt_opts; i++) { char *has_comma; if (opts->mnt_opts[i]) has_comma = strchr(opts->mnt_opts[i], ','); else has_comma = NULL; switch (opts->mnt_opts_flags[i]) { case CONTEXT_MNT: prefix = CONTEXT_STR; break; case FSCONTEXT_MNT: prefix = FSCONTEXT_STR; break; case ROOTCONTEXT_MNT: prefix = ROOTCONTEXT_STR; break; case DEFCONTEXT_MNT: prefix = DEFCONTEXT_STR; break; case SBLABEL_MNT: seq_putc(m, ','); seq_puts(m, LABELSUPP_STR); continue; default: BUG(); return; }; /* we need a comma before each option */ seq_putc(m, ','); seq_puts(m, prefix); if (has_comma) seq_putc(m, '\"'); seq_escape(m, opts->mnt_opts[i], "\"\n\\"); if (has_comma) seq_putc(m, '\"'); } }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris15179.47%350.00%
david p. quigleydavid p. quigley3518.42%116.67%
kees cookkees cook31.58%116.67%
adrian bunkadrian bunk10.53%116.67%
Total190100.00%6100.00%


static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb) { struct security_mnt_opts opts; int rc; rc = selinux_get_mnt_opts(sb, &opts); if (rc) { /* before policy load we may get EINVAL, don't show anything */ if (rc == -EINVAL) rc = 0; return rc; } selinux_write_opts(m, &opts); security_free_mnt_opts(&opts); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris71100.00%2100.00%
Total71100.00%2100.00%


static inline u16 inode_mode_to_security_class(umode_t mode) { switch (mode & S_IFMT) { case S_IFSOCK: return SECCLASS_SOCK_FILE; case S_IFLNK: return SECCLASS_LNK_FILE; case S_IFREG: return SECCLASS_FILE; case S_IFBLK: return SECCLASS_BLK_FILE; case S_IFDIR: return SECCLASS_DIR; case S_IFCHR: return SECCLASS_CHR_FILE; case S_IFIFO: return SECCLASS_FIFO_FILE; } return SECCLASS_FILE; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton63100.00%2100.00%
Total63100.00%2100.00%


static inline int default_protocol_stream(int protocol) { return (protocol == IPPROTO_IP || protocol == IPPROTO_TCP); }

Contributors

PersonTokensPropCommitsCommitProp
james morrisjames morris21100.00%1100.00%
Total21100.00%1100.00%


static inline int default_protocol_dgram(int protocol) { return (protocol == IPPROTO_IP || protocol == IPPROTO_UDP); }

Contributors

PersonTokensPropCommitsCommitProp
james morrisjames morris21100.00%1100.00%
Total21100.00%1100.00%


static inline u16 socket_type_to_security_class(int family, int type, int protocol) { switch (family) { case PF_UNIX: switch (type) { case SOCK_STREAM: case SOCK_SEQPACKET: return SECCLASS_UNIX_STREAM_SOCKET; case SOCK_DGRAM: return SECCLASS_UNIX_DGRAM_SOCKET; } break; case PF_INET: case PF_INET6: switch (type) { case SOCK_STREAM: if (default_protocol_stream(protocol)) return SECCLASS_TCP_SOCKET; else return SECCLASS_RAWIP_SOCKET; case SOCK_DGRAM: if (default_protocol_dgram(protocol)) return SECCLASS_UDP_SOCKET; else return SECCLASS_RAWIP_SOCKET; case SOCK_DCCP: return SECCLASS_DCCP_SOCKET; default: return SECCLASS_RAWIP_SOCKET; } break; case PF_NETLINK: switch (protocol) { case NETLINK_ROUTE: return SECCLASS_NETLINK_ROUTE_SOCKET; case NETLINK_SOCK_DIAG: return SECCLASS_NETLINK_TCPDIAG_SOCKET; case NETLINK_NFLOG: return SECCLASS_NETLINK_NFLOG_SOCKET; case NETLINK_XFRM: return SECCLASS_NETLINK_XFRM_SOCKET; case NETLINK_SELINUX: return SECCLASS_NETLINK_SELINUX_SOCKET; case NETLINK_ISCSI: return SECCLASS_NETLINK_ISCSI_SOCKET; case NETLINK_AUDIT: return SECCLASS_NETLINK_AUDIT_SOCKET; case NETLINK_FIB_LOOKUP: return SECCLASS_NETLINK_FIB_LOOKUP_SOCKET; case NETLINK_CONNECTOR: return SECCLASS_NETLINK_CONNECTOR_SOCKET; case NETLINK_NETFILTER: return SECCLASS_NETLINK_NETFILTER_SOCKET; case NETLINK_DNRTMSG: return SECCLASS_NETLINK_DNRT_SOCKET; case NETLINK_KOBJECT_UEVENT: return SECCLASS_NETLINK_KOBJECT_UEVENT_SOCKET; case NETLINK_GENERIC: return SECCLASS_NETLINK_GENERIC_SOCKET; case NETLINK_SCSITRANSPORT: return SECCLASS_NETLINK_SCSITRANSPORT_SOCKET; case NETLINK_RDMA: return SECCLASS_NETLINK_RDMA_SOCKET; case NETLINK_CRYPTO: return SECCLASS_NETLINK_CRYPTO_SOCKET; default: return SECCLASS_NETLINK_SOCKET; } case PF_PACKET: return SECCLASS_PACKET_SOCKET; case PF_KEY: return SECCLASS_KEY_SOCKET; case PF_APPLETALK: return SECCLASS_APPLETALK_SOCKET; } return SECCLASS_SOCKET; }

Contributors

PersonTokensPropCommitsCommitProp
james morrisjames morris9038.46%444.44%
andrew mortonandrew morton8837.61%111.11%
stephen d. smalleystephen d. smalley4920.94%222.22%
christopher j. pebenitochristopher j. pebenito62.56%111.11%
pavel emelianovpavel emelianov10.43%111.11%
Total234100.00%9100.00%


static int selinux_genfs_get_sid(struct dentry *dentry, u16 tclass, u16 flags, u32 *sid) { int rc; struct super_block *sb = dentry->d_sb; char *buffer, *path; buffer = (char *)__get_free_page(GFP_KERNEL); if (!buffer) return -ENOMEM; path = dentry_path_raw(dentry, buffer, PAGE_SIZE); if (IS_ERR(path)) rc = PTR_ERR(path); else { if (flags & SE_SBPROC) { /* each process gets a /proc/PID/ entry. Strip off the * PID part to get a valid selinux labeling. * e.g. /proc/1/net/rpc/nfs -> /net/rpc/nfs */ while (path[1] >= '0' && path[1] <= '9') { path[1] = '/'; path++; } } rc = security_genfs_sid(sb->s_type->name, path, tclass, sid); } free_page((unsigned long)buffer); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton8857.14%125.00%
lucian adrian grijinculucian adrian grijincu3925.32%125.00%
stephen d. smalleystephen d. smalley2616.88%125.00%
al viroal viro10.65%125.00%
Total154100.00%4100.00%

/* The inode's security attributes must be initialized before first use. */
static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry) { struct superblock_security_struct *sbsec = NULL; struct inode_security_struct *isec = inode->i_security; u32 sid; struct dentry *dentry; #define INITCONTEXTLEN 255 char *context = NULL; unsigned len = 0; int rc = 0; if (isec->initialized == LABEL_INITIALIZED) goto out; mutex_lock(&isec->lock); if (isec->initialized == LABEL_INITIALIZED) goto out_unlock; sbsec = inode->i_sb->s_security; if (!(sbsec->flags & SE_SBINITIALIZED)) { /* Defer initialization until selinux_complete_init, after the initial policy is loaded and the security server is ready to handle calls. */ spin_lock(&sbsec->isec_lock); if (list_empty(&isec->list)) list_add(&isec->list, &sbsec->isec_head); spin_unlock(&sbsec->isec_lock); goto out_unlock; } switch (sbsec->behavior) { case SECURITY_FS_USE_NATIVE: break; case SECURITY_FS_USE_XATTR: if (!inode->i_op->getxattr) { isec->sid = sbsec->def_sid; break; } /* Need a dentry, since the xattr API requires one. Life would be simpler if we could just pass the inode. */ if (opt_dentry) { /* Called from d_instantiate or d_splice_alias. */ dentry = dget(opt_dentry); } else { /* Called from selinux_complete_init, try to find a dentry. */ dentry = d_find_alias(inode); } if (!dentry) { /* * this is can be hit on boot when a file is accessed * before the policy is loaded. When we load policy we * may find inodes that have no dentry on the * sbsec->isec_head list. No reason to complain as these * will get fixed up the next time we go through * inode_doinit with a dentry, before these inodes could * be used again by userspace. */ goto out_unlock; } len = INITCONTEXTLEN; context = kmalloc(len+1, GFP_NOFS); if (!context) { rc = -ENOMEM; dput(dentry); goto out_unlock; } context[len] = '\0'; rc = inode->i_op->getxattr(dentry, inode, XATTR_NAME_SELINUX, context, len); if (rc == -ERANGE) { kfree(context); /* Need a larger buffer. Query for the right size. */ rc = inode->i_op->getxattr(dentry, inode, XATTR_NAME_SELINUX, NULL, 0); if (rc < 0) { dput(dentry); goto out_unlock; } len = rc; context = kmalloc(len+1, GFP_NOFS); if (!context) { rc = -ENOMEM; dput(dentry); goto out_unlock; } context[len] = '\0'; rc = inode->i_op->getxattr(dentry, inode, XATTR_NAME_SELINUX, context, len); } dput(dentry); if (rc < 0) { if (rc != -ENODATA) { printk(KERN_WARNING "SELinux: %s: getxattr returned " "%d for dev=%s ino=%ld\n", __func__, -rc, inode->i_sb->s_id, inode->i_ino); kfree(context); goto out_unlock; } /* Map ENODATA to the default file SID */ sid = sbsec->def_sid; rc = 0; } else { rc = security_context_to_sid_default(context, rc, &sid, sbsec->def_sid, GFP_NOFS); if (rc) { char *dev = inode->i_sb->s_id; unsigned long ino = inode->i_ino; if (rc == -EINVAL) { if (printk_ratelimit()) printk(KERN_NOTICE "SELinux: inode=%lu on dev=%s was found to have an invalid " "context=%s. This indicates you may need to relabel the inode or the " "filesystem in question.\n", ino, dev, context); } else { printk(KERN_WARNING "SELinux: %s: context_to_sid(%s) " "returned %d for dev=%s ino=%ld\n", __func__, context, -rc, dev, ino); } kfree(context); /* Leave with the unlabeled SID */ rc = 0; break; } } kfree(context); isec->sid = sid; break; case SECURITY_FS_USE_TASK: isec->sid = isec->task_sid; break; case SECURITY_FS_USE_TRANS: /* Default to the fs SID. */ isec->sid = sbsec->sid; /* Try to obtain a transition SID. */ isec->sclass = inode_mode_to_security_class(inode->i_mode); rc = security_transition_sid(isec->task_sid, sbsec->sid, isec->sclass, NULL, &sid); if (rc) goto out_unlock; isec->sid = sid; break; case SECURITY_FS_USE_MNTPOINT: isec->sid = sbsec->mntpoint_sid; break; default: /* Default to the fs superblock SID. */ isec->sid = sbsec->sid; if ((sbsec->flags & SE_SBGENFS) && !S_ISLNK(inode->i_mode)) { /* We must have a dentry to determine the label on * procfs inodes */ if (opt_dentry) /* Called from d_instantiate or * d_splice_alias. */ dentry = dget(opt_dentry); else /* Called from selinux_complete_init, try to * find a dentry. */ dentry = d_find_alias(inode); /* * This can be hit on boot when a file is accessed * before the policy is loaded. When we load policy we * may find inodes that have no dentry on the * sbsec->isec_head list. No reason to complain as * these will get fixed up the next time we go through * inode_doinit() with a dentry, before these inodes * could be used again by userspace. */ if (!dentry) goto out_unlock; isec->sclass = inode_mode_to_security_class(inode->i_mode); rc = selinux_genfs_get_sid(dentry, isec->sclass, sbsec->flags, &sid); dput(dentry); if (rc) goto out_unlock; isec->sid = sid; } break; } isec->initialized = LABEL_INITIALIZED; out_unlock: mutex_unlock(&isec->lock); out: if (isec->sclass == SECCLASS_FILE) isec->sclass = inode_mode_to_security_class(inode->i_mode); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton60674.72%312.50%
eric pariseric paris10813.32%729.17%
paul moorepaul moore334.07%14.17%
stephen d. smalleystephen d. smalley273.33%520.83%
james morrisjames morris101.23%28.33%
david p. quigleydavid p. quigley91.11%14.17%
al viroal viro60.74%14.17%
andreas gruenbacherandreas gruenbacher50.62%14.17%
david quigleydavid quigley40.49%14.17%
harvey harrisonharvey harrison20.25%14.17%
lucian adrian grijinculucian adrian grijincu10.12%14.17%
Total811100.00%24100.00%

/* Convert a Linux signal to an access vector. */
static inline u32 signal_to_av(int sig) { u32 perm = 0; switch (sig) { case SIGCHLD: /* Commonly granted from child to parent. */ perm = PROCESS__SIGCHLD; break; case SIGKILL: /* Cannot be caught or ignored */ perm = PROCESS__SIGKILL; break; case SIGSTOP: /* Cannot be caught or ignored */ perm = PROCESS__SIGSTOP; break; default: /* All other signals. */ perm = PROCESS__SIGNAL; break; } return perm; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton58100.00%1100.00%
Total58100.00%1100.00%

/* * Check permission between a pair of credentials * fork check, ptrace check, etc. */
static int cred_has_perm(const struct cred *actor, const struct cred *target, u32 perms) { u32 asid = cred_sid(actor), tsid = cred_sid(target); return avc_has_perm(asid, tsid, SECCLASS_PROCESS, perms, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells50100.00%1100.00%
Total50100.00%1100.00%

/* * Check permission between a pair of tasks, e.g. signal checks, * fork check, ptrace check, etc. * tsk1 is the actor and tsk2 is the target * - this uses the default subjective creds of tsk1 */
static int task_has_perm(const struct task_struct *tsk1, const struct task_struct *tsk2, u32 perms) { const struct task_security_struct *__tsec1, *__tsec2; u32 sid1, sid2; rcu_read_lock(); __tsec1 = __task_cred(tsk1)->security; sid1 = __tsec1->sid; __tsec2 = __task_cred(tsk2)->security; sid2 = __tsec2->sid; rcu_read_unlock(); return avc_has_perm(sid1, sid2, SECCLASS_PROCESS, perms, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4451.76%125.00%
david howellsdavid howells4047.06%250.00%
stephen d. smalleystephen d. smalley11.18%125.00%
Total85100.00%4100.00%

/* * Check permission between current and another task, e.g. signal checks, * fork check, ptrace check, etc. * current is the actor and tsk2 is the target * - this uses current's subjective creds */
static int current_has_perm(const struct task_struct *tsk, u32 perms) { u32 sid, tsid; sid = current_sid(); tsid = task_sid(tsk); return avc_has_perm(sid, tsid, SECCLASS_PROCESS, perms, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells46100.00%1100.00%
Total46100.00%1100.00%

#if CAP_LAST_CAP > 63 #error Fix SELinux to handle capabilities > 63. #endif /* Check whether a task is allowed to use a capability. */
static int cred_has_capability(const struct cred *cred, int cap, int audit, bool initns) { struct common_audit_data ad; struct av_decision avd; u16 sclass; u32 sid = cred_sid(cred); u32 av = CAP_TO_MASK(cap); int rc; ad.type = LSM_AUDIT_DATA_CAP; ad.u.cap = cap; switch (CAP_TO_INDEX(cap)) { case 0: sclass = initns ? SECCLASS_CAPABILITY : SECCLASS_CAP_USERNS; break; case 1: sclass = initns ? SECCLASS_CAPABILITY2 : SECCLASS_CAP2_USERNS; break; default: printk(KERN_ERR "SELinux: out of range capability %d\n", cap); BUG(); return -EINVAL; } rc = avc_has_perm_noaudit(sid, sid, sclass, av, 0, &avd); if (audit == SECURITY_CAP_AUDIT) { int rc2 = avc_audit(sid, sid, sclass, av, &avd, rc, &ad, 0); if (rc2) return rc2; } return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris6235.63%642.86%
stephen d. smalleystephen d. smalley6235.63%321.43%
andrew mortonandrew morton3318.97%17.14%
david howellsdavid howells148.05%214.29%
neil brownneil brown21.15%17.14%
thomas liuthomas liu10.57%17.14%
Total174100.00%14100.00%

/* Check whether a task is allowed to use a system operation. */
static int task_has_system(struct task_struct *tsk, u32 perms) { u32 sid = task_sid(tsk); return avc_has_perm(sid, SECINITSID_KERNEL, SECCLASS_SYSTEM, perms, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2877.78%133.33%
david howellsdavid howells719.44%133.33%
stephen d. smalleystephen d. smalley12.78%133.33%
Total36100.00%3100.00%

/* Check whether a task has a particular permission to an inode. The 'adp' parameter is optional and allows other audit data to be passed (e.g. the dentry). */
static int inode_has_perm(const struct cred *cred, struct inode *inode, u32 perms, struct common_audit_data *adp) { struct inode_security_struct *isec; u32 sid; validate_creds(cred); if (unlikely(IS_PRIVATE(inode))) return 0; sid = cred_sid(cred); isec = inode->i_security; return avc_has_perm(sid, isec->sid, isec->sclass, perms, adp); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3340.24%111.11%
linus torvaldslinus torvalds1821.95%222.22%
david howellsdavid howells1619.51%333.33%
stephen d. smalleystephen d. smalley1417.07%222.22%
thomas liuthomas liu11.22%111.11%
Total82100.00%9100.00%

/* Same as inode_has_perm, but pass explicit audit data containing the dentry to help the auditing code to more easily generate the pathname if needed. */
static inline int dentry_has_perm(const struct cred *cred, struct dentry *dentry, u32 av) { struct inode *inode = d_backing_inode(dentry); struct common_audit_data ad; ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = dentry; __inode_security_revalidate(inode, dentry, true); return inode_has_perm(cred, inode, av, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3447.89%112.50%
eric pariseric paris2129.58%337.50%
andreas gruenbacherandreas gruenbacher912.68%112.50%
david howellsdavid howells68.45%225.00%
thomas liuthomas liu11.41%112.50%
Total71100.00%8100.00%

/* Same as inode_has_perm, but pass explicit audit data containing the path to help the auditing code to more easily generate the pathname if needed. */
static inline int path_has_perm(const struct cred *cred, const struct path *path, u32 av) { struct inode *inode = d_backing_inode(path->dentry); struct common_audit_data ad; ad.type = LSM_AUDIT_DATA_PATH; ad.u.path = *path; __inode_security_revalidate(inode, path->dentry, true); return inode_has_perm(cred, inode, av, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris4051.95%333.33%
andrew mortonandrew morton2025.97%111.11%
andreas gruenbacherandreas gruenbacher1114.29%111.11%
david howellsdavid howells45.19%222.22%
al viroal viro11.30%111.11%
jan blunckjan blunck11.30%111.11%
Total77100.00%9100.00%

/* Same as path_has_perm, but uses the inode from the file struct. */
static inline int file_path_has_perm(const struct cred *cred, struct file *file, u32 av) { struct common_audit_data ad; ad.type = LSM_AUDIT_DATA_PATH; ad.u.path = file->f_path; return inode_has_perm(cred, file_inode(file), av, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells57100.00%1100.00%
Total57100.00%1100.00%

/* Check whether a task can use an open file descriptor to access an inode in a given way. Check access to the descriptor itself, and then use dentry_has_perm to check a particular permission to the file. Access to the descriptor is implicitly granted if it has the same SID as the process. If av is zero, then access to the file is not checked, e.g. for cases where only the descriptor is affected like seek. */
static int file_has_perm(const struct cred *cred, struct file *file, u32 av) { struct file_security_struct *fsec = file->f_security; struct inode *inode = file_inode(file); struct common_audit_data ad; u32 sid = cred_sid(cred); int rc; ad.type = LSM_AUDIT_DATA_PATH; ad.u.path = file->f_path; if (sid != fsec->sid) { rc = avc_has_perm(sid, fsec->sid, SECCLASS_FD, FD__USE, &ad); if (rc) goto out; } /* av is zero if only checking access to the descriptor. */ rc = 0; if (av) rc = inode_has_perm(cred, inode, av, &ad); out: return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton9470.68%112.50%
david howellsdavid howells2518.80%225.00%
jan blunckjan blunck64.51%112.50%
eric pariseric paris43.01%225.00%
al viroal viro32.26%112.50%
thomas liuthomas liu10.75%112.50%
Total133100.00%8100.00%

/* * Determine the label for an inode that might be unioned. */
static int selinux_determine_inode_label(struct inode *dir, const struct qstr *name, u16 tclass, u32 *_new_isid) { const struct superblock_security_struct *sbsec = dir->i_sb->s_security; const struct task_security_struct *tsec = current_security(); if ((sbsec->flags & SE_SBINITIALIZED) && (sbsec->behavior == SECURITY_FS_USE_MNTPOINT)) { *_new_isid = sbsec->mntpoint_sid; } else if ((sbsec->flags & SBLABEL_MNT) && tsec->create_sid) { *_new_isid = tsec->create_sid; } else { const struct inode_security_struct *dsec = inode_security(dir); return security_transition_sid(tsec->sid, dsec->sid, tclass, name, _new_isid); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells12091.60%150.00%
paul moorepaul moore118.40%150.00%
Total131100.00%2100.00%

/* Check whether a task can create a file. */
static int may_create(struct inode *dir, struct dentry *dentry, u16 tclass) { const struct task_security_struct *tsec = current_security(); struct inode_security_struct *dsec; struct superblock_security_struct *sbsec; u32 sid, newsid; struct common_audit_data ad; int rc; dsec = inode_security(dir); sbsec = dir->i_sb->s_security; sid = tsec->sid; ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = dentry; rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR, DIR__ADD_NAME | DIR__SEARCH, &ad); if (rc) return rc; rc = selinux_determine_inode_label(dir, &dentry->d_name, tclass, &newsid); if (rc) return rc; rc = avc_has_perm(sid, newsid, tclass, FILE__CREATE, &ad); if (rc) return rc; return avc_has_perm(newsid, sbsec->sid, SECCLASS_FILESYSTEM, FILESYSTEM__ASSOCIATE, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton14682.95%218.18%
david howellsdavid howells158.52%218.18%
eric pariseric paris95.11%436.36%
andreas gruenbacherandreas gruenbacher31.70%19.09%
paul moorepaul moore21.14%19.09%
thomas liuthomas liu10.57%19.09%
Total176100.00%11100.00%

/* Check whether a task can create a key. */
static int may_create_key(u32 ksid, struct task_struct *ctx) { u32 sid = task_sid(ctx); return avc_has_perm(sid, ksid, SECCLASS_KEY, KEY__CREATE, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
michael lemaymichael lemay2980.56%150.00%
david howellsdavid howells719.44%150.00%
Total36100.00%2100.00%

#define MAY_LINK 0 #define MAY_UNLINK 1 #define MAY_RMDIR 2 /* Check whether a task can link, unlink, or rmdir a file/directory. */
static int may_link(struct inode *dir, struct dentry *dentry, int kind) { struct inode_security_struct *dsec, *isec; struct common_audit_data ad; u32 sid = current_sid(); u32 av; int rc; dsec = inode_security(dir); isec = backing_inode_security(dentry); ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = dentry; av = DIR__SEARCH; av |= (kind ? DIR__REMOVE_NAME : DIR__ADD_NAME); rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR, av, &ad); if (rc) return rc; switch (kind) { case MAY_LINK: av = FILE__LINK; break; case MAY_UNLINK: av = FILE__UNLINK; break; case MAY_RMDIR: av = DIR__RMDIR; break; default: printk(KERN_WARNING "SELinux: %s: unrecognized kind %d\n", __func__, kind); return 0; } rc = avc_has_perm(sid, isec->sid, isec->sclass, av, &ad); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton15788.70%112.50%
david howellsdavid howells84.52%225.00%
eric pariseric paris73.95%337.50%
andreas gruenbacherandreas gruenbacher42.26%112.50%
thomas liuthomas liu10.56%112.50%
Total177100.00%8100.00%


static inline int may_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { struct inode_security_struct *old_dsec, *new_dsec, *old_isec, *new_isec; struct common_audit_data ad; u32 sid = current_sid(); u32 av; int old_is_dir, new_is_dir; int rc; old_dsec = inode_security(old_dir); old_isec = backing_inode_security(old_dentry); old_is_dir = d_is_dir(old_dentry); new_dsec = inode_security(new_dir); ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = old_dentry; rc = avc_has_perm(sid, old_dsec->sid, SECCLASS_DIR, DIR__REMOVE_NAME | DIR__SEARCH, &ad); if (rc) return rc; rc = avc_has_perm(sid, old_isec->sid, old_isec->sclass, FILE__RENAME, &ad); if (rc) return rc; if (old_is_dir && new_dir != old_dir) { rc = avc_has_perm(sid, old_isec->sid, old_isec->sclass, DIR__REPARENT, &ad); if (rc) return rc; } ad.u.dentry = new_dentry; av = DIR__ADD_NAME | DIR__SEARCH; if (d_is_positive(new_dentry)) av |= DIR__REMOVE_NAME; rc = avc_has_perm(sid, new_dsec->sid, SECCLASS_DIR, av, &ad); if (rc) return rc; if (d_is_positive(new_dentry)) { new_isec = backing_inode_security(new_dentry); new_is_dir = d_is_dir(new_dentry); rc = avc_has_perm(sid, new_isec->sid, new_isec->sclass, (new_is_dir ? DIR__RMDIR : FILE__UNLINK), &ad); if (rc) return rc; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton27189.14%110.00%
david howellsdavid howells185.92%440.00%
andreas gruenbacherandreas gruenbacher82.63%110.00%
eric pariseric paris61.97%330.00%
thomas liuthomas liu10.33%110.00%
Total304100.00%10100.00%

/* Check whether a task can perform a filesystem operation. */
static int superblock_has_perm(const struct cred *cred, struct super_block *sb, u32 perms, struct common_audit_data *ad) { struct superblock_security_struct *sbsec; u32 sid = cred_sid(cred); sbsec = sb->s_security; return avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM, perms, ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4778.33%120.00%
david howellsdavid howells1118.33%240.00%
stephen d. smalleystephen d. smalley11.67%120.00%
thomas liuthomas liu11.67%120.00%
Total60100.00%5100.00%

/* Convert a Linux mode and permission mask to an access vector. */
static inline u32 file_mask_to_av(int mode, int mask) { u32 av = 0; if (!S_ISDIR(mode)) { if (mask & MAY_EXEC) av |= FILE__EXECUTE; if (mask & MAY_READ) av |= FILE__READ; if (mask & MAY_APPEND) av |= FILE__APPEND; else if (mask & MAY_WRITE) av |= FILE__WRITE; } else { if (mask & MAY_EXEC) av |= DIR__SEARCH; if (mask & MAY_WRITE) av |= DIR__WRITE; if (mask & MAY_READ) av |= DIR__READ; } return av; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton10196.19%150.00%
al viroal viro43.81%150.00%
Total105100.00%2100.00%

/* Convert a Linux file to an access vector. */
static inline u32 file_to_av(struct file *file) { u32 av = 0; if (file->f_mode & FMODE_READ) av |= FILE__READ; if (file->f_mode & FMODE_WRITE) { if (file->f_flags & O_APPEND) av |= FILE__APPEND; else av |= FILE__WRITE; } if (!av) { /* * Special file opened with flags 3 for ioctl-only use. */ av = FILE__IOCTL; } return av; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris71100.00%2100.00%
Total71100.00%2100.00%

/* * Convert a file to an access vector and include the correct open * open permission. */
static inline u32 open_file_to_av(struct file *file) { u32 av = file_to_av(file); if (selinux_policycap_openperm) av |= FILE__OPEN; return av; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris31100.00%2100.00%
Total31100.00%2100.00%

/* Hook functions begin here. */
static int selinux_binder_set_context_mgr(struct task_struct *mgr) { u32 mysid = current_sid(); u32 mgrsid = task_sid(mgr); return avc_has_perm(mysid, mgrsid, SECCLASS_BINDER, BINDER__SET_CONTEXT_MGR, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley39100.00%1100.00%
Total39100.00%1100.00%


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); int rc; if (mysid != fromsid) { rc = avc_has_perm(mysid, fromsid, SECCLASS_BINDER, BINDER__IMPERSONATE, NULL); if (rc) return rc; } return avc_has_perm(fromsid, tosid, SECCLASS_BINDER, BINDER__CALL, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley85100.00%1100.00%
Total85100.00%1100.00%


static int selinux_binder_transfer_binder(struct task_struct *from, struct task_struct *to) { u32 fromsid = task_sid(from); u32 tosid = task_sid(to); return avc_has_perm(fromsid, tosid, SECCLASS_BINDER, BINDER__TRANSFER, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley46100.00%1100.00%
Total46100.00%1100.00%


static int selinux_binder_transfer_file(struct task_struct *from, struct task_struct *to, struct file *file) { u32 sid = task_sid(to); struct file_security_struct *fsec = file->f_security; struct dentry *dentry = file->f_path.dentry; struct inode_security_struct *isec; struct common_audit_data ad; int rc; ad.type = LSM_AUDIT_DATA_PATH; ad.u.path = file->f_path; if (sid != fsec->sid) { rc = avc_has_perm(sid, fsec->sid, SECCLASS_FD, FD__USE, &ad); if (rc) return rc; } if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) return 0; isec = backing_inode_security(dentry); return avc_has_perm(sid, isec->sid, isec->sclass, file_to_av(file), &ad); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley14491.72%133.33%
paul moorepaul moore74.46%133.33%
andreas gruenbacherandreas gruenbacher63.82%133.33%
Total157100.00%3100.00%


static int selinux_ptrace_access_check(struct task_struct *child, unsigned int mode) { if (mode & PTRACE_MODE_READ) { u32 sid = current_sid(); u32 csid = task_sid(child); return avc_has_perm(sid, csid, SECCLASS_FILE, FILE__READ, NULL); } return current_has_perm(child, PROCESS__PTRACE); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley2949.15%114.29%
andrew mortonandrew morton1627.12%114.29%
david howellsdavid howells1118.64%228.57%
roland mcgrathroland mcgrath11.69%114.29%
eric pariseric paris11.69%114.29%
ingo molnaringo molnar11.69%114.29%
Total59100.00%7100.00%


static int selinux_ptrace_traceme(struct task_struct *parent) { return task_has_perm(parent, current, PROCESS__PTRACE); }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells21100.00%1100.00%
Total21100.00%1100.00%


static int selinux_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted) { return current_has_perm(target, PROCESS__GETCAP); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2993.55%133.33%
david howellsdavid howells13.23%133.33%
casey schauflercasey schaufler13.23%133.33%
Total31100.00%3100.00%


static int selinux_capset(struct cred *new, const struct cred *old, const kernel_cap_t *effective, const kernel_cap_t *inheritable, const kernel_cap_t *permitted) { return cred_has_perm(old, new, PROCESS__SETCAP); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2457.14%250.00%
david howellsdavid howells1842.86%250.00%
Total42100.00%4100.00%

/* * (This comment used to live with the selinux_task_setuid hook, * which was removed). * * Since setuid only affects the current process, and since the SELinux * controls are not based on the Linux identity attributes, SELinux does not * need to control this operation. However, SELinux does control the use of * the CAP_SETUID and CAP_SETGID capabilities using the capable hook. */
static int selinux_capable(const struct cred *cred, struct user_namespace *ns, int cap, int audit) { return cred_has_capability(cred, cap, audit, ns == &init_user_ns); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1436.84%116.67%
david howellsdavid howells821.05%116.67%
eric pariseric paris615.79%233.33%
serge hallynserge hallyn513.16%116.67%
stephen d. smalleystephen d. smalley513.16%116.67%
Total38100.00%6100.00%


static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb) { const struct cred *cred = current_cred(); int rc = 0; if (!sb) return 0; switch (cmds) { case Q_SYNC: case Q_QUOTAON: case Q_QUOTAOFF: case Q_SETINFO: case Q_SETQUOTA: rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAMOD, NULL); break; case Q_GETFMT: case Q_GETINFO: case Q_GETQUOTA: rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAGET, NULL); break; default: rc = 0; /* let the kernel handle invalid cmds */ break; } return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton7265.45%125.00%
eric w. biedermaneric w. biederman2926.36%250.00%
david howellsdavid howells98.18%125.00%
Total110100.00%4100.00%


static int selinux_quota_on(struct dentry *dentry) { const struct cred *cred = current_cred(); return dentry_has_perm(cred, dentry, FILE__QUOTAON); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1343.33%125.00%
david howellsdavid howells1033.33%125.00%
jan karajan kara413.33%125.00%
eric w. biedermaneric w. biederman310.00%125.00%
Total30100.00%4100.00%


static int selinux_syslog(int type) { int rc; switch (type) { case SYSLOG_ACTION_READ_ALL: /* Read last kernel messages */ case SYSLOG_ACTION_SIZE_BUFFER: /* Return size of the log buffer */ rc = task_has_system(current, SYSTEM__SYSLOG_READ); break; case SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging to console */ case SYSLOG_ACTION_CONSOLE_ON: /* Enable logging to console */ /* Set level of messages printed to console */ case SYSLOG_ACTION_CONSOLE_LEVEL: rc = task_has_system(current, SYSTEM__SYSLOG_CONSOLE); break; case SYSLOG_ACTION_CLOSE: /* Close log */ case SYSLOG_ACTION_OPEN: /* Open log */ case SYSLOG_ACTION_READ: /* Read from log */ case SYSLOG_ACTION_READ_CLEAR: /* Read/clear last kernel messages */ case SYSLOG_ACTION_CLEAR: /* Clear ring buffer */ default: rc = task_has_system(current, SYSTEM__SYSLOG_MOD); break; } return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton6671.74%240.00%
eric w. biedermaneric w. biederman1516.30%240.00%
kees cookkees cook1111.96%120.00%
Total92100.00%5100.00%

/* * Check that a process has enough memory to allocate a new virtual * mapping. 0 means there is enough memory for the allocation to * succeed and -ENOMEM implies there is not. * * Do not audit the selinux permission check, as this is applied to all * processes that allocate mappings. */
static int selinux_vm_enough_memory(struct mm_struct *mm, long pages) { int rc, cap_sys_admin = 0; rc = cred_has_capability(current_cred(), CAP_SYS_ADMIN, SECURITY_CAP_NOAUDIT, true); if (rc == 0) cap_sys_admin = 1; return cap_sys_admin; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3164.58%114.29%
serge hallynserge hallyn714.58%114.29%
alan coxalan cox36.25%114.29%
eric pariseric paris24.17%114.29%
david howellsdavid howells24.17%114.29%
stephen d. smalleystephen d. smalley24.17%114.29%
casey schauflercasey schaufler12.08%114.29%
Total48100.00%7100.00%

/* binprm security operations */
static u32 ptrace_parent_sid(struct task_struct *task) { u32 sid = 0; struct task_struct *tracer; rcu_read_lock(); tracer = ptrace_parent(task); if (tracer) sid = task_sid(tracer); rcu_read_unlock(); return sid; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore48100.00%1100.00%
Total48100.00%1100.00%


static int check_nnp_nosuid(const struct linux_binprm *bprm, const struct task_security_struct *old_tsec, const struct task_security_struct *new_tsec) { int nnp = (bprm->unsafe & LSM_UNSAFE_NO_NEW_PRIVS); int nosuid = (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID); int rc; if (!nnp && !nosuid) return 0; /* neither NNP nor nosuid */ if (new_tsec->sid == old_tsec->sid) return 0; /* No change in credentials */ /* * The only transitions we permit under NNP or nosuid * are transitions to bounded SIDs, i.e. SIDs that are * guaranteed to only be allowed a subset of the permissions * of the current SID. */ rc = security_bounded_transition(old_tsec->sid, new_tsec->sid); if (rc) { /* * On failure, preserve the errno values for NNP vs nosuid. * NNP: Operation not permitted for caller. * nosuid: Permission denied to file. */ if (nnp) return -EPERM; else return -EACCES; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley118100.00%1100.00%
Total118100.00%1100.00%


static int selinux_bprm_set_creds(struct linux_binprm *bprm) { const struct task_security_struct *old_tsec; struct task_security_struct *new_tsec; struct inode_security_struct *isec; struct common_audit_data ad; struct inode *inode = file_inode(bprm->file); int rc; /* SELinux context only depends on initial program or script and not * the script interpreter */ if (bprm->cred_prepared) return 0; old_tsec = current_security(); new_tsec = bprm->cred->security; isec = inode_security(inode); /* Default to the current task SID. */ new_tsec->sid = old_tsec->sid; new_tsec->osid = old_tsec->sid; /* Reset fs, key, and sock SIDs on execve. */ new_tsec->create_sid = 0; new_tsec->keycreate_sid = 0; new_tsec->sockcreate_sid = 0; if (old_tsec->exec_sid) { new_tsec->sid = old_tsec->exec_sid; /* Reset exec SID on execve. */ new_tsec->exec_sid = 0; /* Fail on NNP or nosuid if not an allowed transition. */ rc = check_nnp_nosuid(bprm, old_tsec, new_tsec); if (rc) return rc; } else { /* Check for a default transition on this program. */ rc = security_transition_sid(old_tsec->sid, isec->sid, SECCLASS_PROCESS, NULL, &new_tsec->sid); if (rc) return rc; /* * Fallback to old SID on NNP or nosuid if not an allowed * transition. */ rc = check_nnp_nosuid(bprm, old_tsec, new_tsec); if (rc) new_tsec->sid = old_tsec->sid; } ad.type = LSM_AUDIT_DATA_PATH; ad.u.path = bprm->file->f_path; if (new_tsec->sid == old_tsec->sid) { rc = avc_has_perm(old_tsec->sid, isec->sid, SECCLASS_FILE, FILE__EXECUTE_NO_TRANS, &ad); if (rc) return rc; } else { /* Check permissions for the transition. */ rc = avc_has_perm(old_tsec->sid, new_tsec->sid, SECCLASS_PROCESS, PROCESS__TRANSITION, &ad); if (rc) return rc; rc = avc_has_perm(new_tsec->sid, isec->sid, SECCLASS_FILE, FILE__ENTRYPOINT, &ad); if (rc) return rc; /* Check for shared state */ if (bprm->unsafe & LSM_UNSAFE_SHARE) { rc = avc_has_perm(old_tsec->sid, new_tsec->sid, SECCLASS_PROCESS, PROCESS__SHARE, NULL); if (rc) return -EPERM; } /* Make sure that anyone attempting to ptrace over a task that * changes its SID has the appropriate permit */ if (bprm->unsafe & (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) { u32 ptsid = ptrace_parent_sid(current); if (ptsid != 0) { rc = avc_has_perm(ptsid, new_tsec->sid, SECCLASS_PROCESS, PROCESS__PTRACE, NULL); if (rc) return -EPERM; } } /* Clear any possibly unsafe personality bits on exec: */ bprm->per_clear |= PER_CLEAR_ON_SETID; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton20146.74%210.00%
david howellsdavid howells15536.05%210.00%
stephen d. smalleystephen d. smalley388.84%210.00%
eric pariseric paris133.02%525.00%
paul moorepaul moore71.63%210.00%
michael lemaymichael lemay61.40%15.00%
al viroal viro30.70%15.00%
andreas gruenbacherandreas gruenbacher30.70%15.00%
thomas liuthomas liu10.23%15.00%
andy lutomirskiandy lutomirski10.23%15.00%
josef sipekjosef sipek10.23%15.00%
jan blunckjan blunck10.23%15.00%
Total430100.00%20100.00%


static int selinux_bprm_secureexec(struct linux_binprm *bprm) { const struct task_security_struct *tsec = current_security(); u32 sid, osid; int atsecure = 0; sid = tsec->sid; osid = tsec->osid; if (osid != sid) { /* Enable secure mode for SIDs transitions unless the noatsecure permission is granted between the two SIDs, i.e. ahp returns 0. */ atsecure = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__NOATSECURE, NULL); } return !!atsecure; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4867.61%125.00%
david howellsdavid howells1926.76%125.00%
paul moorepaul moore22.82%125.00%
casey schauflercasey schaufler22.82%125.00%
Total71100.00%4100.00%


static int match_file(const void *p, struct file *file, unsigned fd) { return file_has_perm(p, file, file_to_av(file)) ? fd + 1 : 0; }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro38100.00%1100.00%
Total38100.00%1100.00%

/* Derived from fs/exec.c:flush_old_files. */
static inline void flush_unauthorized_files(const struct cred *cred, struct files_struct *files) { struct file *file, *devnull = NULL; struct tty_struct *tty; int drop_tty = 0; unsigned n; tty = get_current_tty(); if (tty) { spin_lock(&tty->files_lock); if (!list_empty(&tty->tty_files)) { struct tty_file_private *file_priv; /* Revalidate access to controlling tty. Use file_path_has_perm on the tty path directly rather than using file_has_perm, as this particular open file may belong to another process and we are only interested in the inode-based check here. */ file_priv = list_first_entry(&tty->tty_files, struct tty_file_private, list); file = file_priv->file; if (file_path_has_perm(cred, file, FILE__READ | FILE__WRITE)) drop_tty = 1; } spin_unlock(&tty->files_lock); tty_kref_put(tty); } /* Reset controlling tty. */ if (drop_tty) no_tty(); /* Revalidate access to inherited open files. */ n = iterate_fd(files, 0, match_file, cred); if (!n) /* none found? */ return; devnull = dentry_open(&selinux_null, O_RDWR, cred); if (IS_ERR(devnull)) devnull = NULL; /* replace all the matching ones with this */ do { replace_fd(n - 1, devnull, 0); } while ((n = iterate_fd(files, n, match_file, cred)) != 0); if (devnull) fput(devnull); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro5323.45%417.39%
stephen d. smalleystephen d. smalley4720.80%313.04%
andrew mortonandrew morton4620.35%313.04%
nick pigginnick piggin219.29%28.70%
eric pariseric paris177.52%28.70%
david howellsdavid howells114.87%313.04%
peter zijlstrapeter zijlstra93.98%14.35%
eric w. biedermaneric w. biederman83.54%14.35%
peter hurleypeter hurley62.65%14.35%
alan coxalan cox31.33%14.35%
akinobu mitaakinobu mita31.33%14.35%
dipankar sarmadipankar sarma20.88%14.35%
Total226100.00%23100.00%

/* * Prepare a process for imminent new credential changes due to exec */
static void selinux_bprm_committing_creds(struct linux_binprm *bprm) { struct task_security_struct *new_tsec; struct rlimit *rlim, *initrlim; int rc, i; new_tsec = bprm->cred->security; if (new_tsec->sid == new_tsec->osid) return; /* Close files for which the new task SID is not authorized. */ flush_unauthorized_files(bprm->cred, current->files); /* Always clear parent death signal on SID transitions. */ current->pdeath_signal = 0; /* Check whether the new SID can inherit resource limits from the old * SID. If not, reset all soft limits to the lower of the current * task's hard limit and the init task's soft limit. * * Note that the setting of hard limits (even to lower them) can be * controlled by the setrlimit check. The inclusion of the init task's * soft limit into the computation is to avoid resetting soft limits * higher than the default soft limit for cases where the default is * lower than the hard limit, e.g. RLIMIT_CORE or RLIMIT_STACK. */ rc = avc_has_perm(new_tsec->osid, new_tsec->sid, SECCLASS_PROCESS, PROCESS__RLIMITINH, NULL); if (rc) { /* protect against do_prlimit() */ task_lock(current); for (i = 0; i < RLIM_NLIMITS; i++) { rlim = current->signal->rlim + i; initrlim = init_task.signal->rlim + i; rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur); } task_unlock(current); update_rlimit_cpu(current, rlimit(RLIMIT_CPU)); } }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells8652.44%222.22%
andrew mortonandrew morton4728.66%222.22%
oleg nesterovoleg nesterov148.54%111.11%
serge hallynserge hallyn106.10%111.11%
roland mcgrathroland mcgrath42.44%111.11%
jiri slabyjiri slaby31.83%222.22%
Total164100.00%9100.00%

/* * Clean up the process immediately after the installation of new credentials * due to exec */
static void selinux_bprm_committed_creds(struct linux_binprm *bprm) { const struct task_security_struct *tsec = current_security(); struct itimerval itimer; u32 osid, sid; int rc, i; osid = tsec->osid; sid = tsec->sid; if (sid == osid) return; /* Check whether the new SID can inherit signal state from the old SID. * If not, clear itimers to avoid subsequent signal generation and * flush and unblock signals. * * This must occur _after_ the task SID has been updated so that any * kill done after the flush will be checked against the new SID. */ rc = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__SIGINH, NULL); if (rc) { memset(&itimer, 0, sizeof itimer); for (i = 0; i < 3; i++) do_setitimer(i, &itimer, NULL); spin_lock_irq(&current->sighand->siglock); if (!fatal_signal_pending(current)) { flush_sigqueue(&current->pending); flush_sigqueue(&current->signal->shared_pending); flush_signal_handlers(current, 1); sigemptyset(&current->blocked); recalc_sigpending(); } spin_unlock_irq(&current->sighand->siglock); } /* Wake up the parent if it is waiting so that it can recheck * wait permission to the new task SID. */ read_lock(&tasklist_lock); __wake_up_parent(current, current->real_parent); read_unlock(&tasklist_lock); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton9950.25%327.27%
david howellsdavid howells3718.78%327.27%
serge hallynserge hallyn2713.71%19.09%
oleg nesterovoleg nesterov2412.18%327.27%
eric pariseric paris105.08%19.09%
Total197100.00%11100.00%

/* superblock security operations */
static int selinux_sb_alloc_security(struct super_block *sb) { return superblock_alloc_security(sb); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton17100.00%2100.00%
Total17100.00%2100.00%


static void selinux_sb_free_security(struct super_block *sb) { superblock_free_security(sb); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton16100.00%1100.00%
Total16100.00%1100.00%


static inline int match_prefix(char *prefix, int plen, char *option, int olen) { if (plen > olen) return 0; return !memcmp(prefix, option, plen); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton41100.00%2100.00%
Total41100.00%2100.00%


static inline int selinux_option(char *option, int len) { return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) || match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) || match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) || match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) || match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len)); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5960.82%240.00%
eric pariseric paris2222.68%240.00%
david p. quigleydavid p. quigley1616.49%120.00%
Total97100.00%5100.00%


static inline void take_option(char **to, char *from, int *first, int len) { if (!*first) { **to = ','; *to += 1; } else *first = 0; memcpy(*to, from, len); *to += len; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton63100.00%2100.00%
Total63100.00%2100.00%


static inline void take_selinux_option(char **to, char *from, int *first, int len) { int current_size = 0; if (!*first) { **to = '|'; *to += 1; } else *first = 0; while (current_size < len) { if (*from != '"') { **to = *from; *to += 1; } from += 1; current_size += 1; } }

Contributors

PersonTokensPropCommitsCommitProp
cory olmocory olmo90100.00%1100.00%
Total90100.00%1100.00%


static int selinux_sb_copy_data(char *orig, char *copy) { int fnosec, fsec, rc = 0; char *in_save, *in_curr, *in_end; char *sec_curr, *nosec_save, *nosec; int open_quote = 0; in_curr = orig; sec_curr = copy; nosec = (char *)get_zeroed_page(GFP_KERNEL); if (!nosec) { rc = -ENOMEM; goto out; } nosec_save = nosec; fnosec = fsec = 1; in_save = in_end = orig; do { if (*in_end == '"') open_quote = !open_quote; if ((*in_end == ',' && open_quote == 0) || *in_end == '\0') { int len = in_end - in_curr; if (selinux_option(in_curr, len)) take_selinux_option(&sec_curr, in_curr, &fsec, len); else take_option(&nosec, in_curr, &fnosec, len); in_curr = in_end + 1; } } while (*in_end++); strcpy(in_save, nosec_save); free_page((unsigned long)nosec_save); out: return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton17482.86%450.00%
cory olmocory olmo2411.43%112.50%
gerald schaefergerald schaefer94.29%112.50%
eric pariseric paris31.43%225.00%
Total210100.00%8100.00%


static int selinux_sb_remount(struct super_block *sb, void *data) { int rc, i, *flags; struct security_mnt_opts opts; char *secdata, **mount_options; struct superblock_security_struct *sbsec = sb->s_security; if (!(sbsec->flags & SE_SBINITIALIZED)) return 0; if (!data) return 0; if (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA) return 0; security_init_mnt_opts(&opts); secdata = alloc_secdata(); if (!secdata) return -ENOMEM; rc = selinux_sb_copy_data(data, secdata); if (rc) goto out_free_secdata; rc = selinux_parse_opts_str(secdata, &opts); if (rc) goto out_free_secdata; mount_options = opts.mnt_opts; flags = opts.mnt_opts_flags; for (i = 0; i < opts.num_mnt_opts; i++) { u32 sid; if (flags[i] == SBLABEL_MNT) continue; rc = security_context_str_to_sid(mount_options[i], &sid, GFP_KERNEL); if (rc) { printk(KERN_WARNING "SELinux: security_context_str_to_sid" "(%s) failed for (dev %s, type %s) errno=%d\n", mount_options[i], sb->s_id, sb->s_type->name, rc); goto out_free_opts; } rc = -EINVAL; switch (flags[i]) { case FSCONTEXT_MNT: if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid, sid)) goto out_bad_option; break; case CONTEXT_MNT: if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid, sid)) goto out_bad_option; break; case ROOTCONTEXT_MNT: { struct inode_security_struct *root_isec; root_isec = backing_inode_security(sb->s_root); if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, sid)) goto out_bad_option; break; } case DEFCONTEXT_MNT: if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid, sid)) goto out_bad_option; break; default: goto out_free_opts; } } rc = 0; out_free_opts: security_free_mnt_opts(&opts); out_free_secdata: free_secdata(secdata); return rc; out_bad_option: printk(KERN_WARNING "SELinux: unable to change security options " "during remount (dev %s, type=%s)\n", sb->s_id, sb->s_type->name); goto out_free_opts; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris29876.80%216.67%
andrew mortonandrew morton6416.49%325.00%
linus torvaldslinus torvalds102.58%18.33%
cory olmocory olmo61.55%18.33%
gerald schaefergerald schaefer30.77%18.33%
david howellsdavid howells20.52%18.33%
nikolay aleksandrovnikolay aleksandrov20.52%18.33%
rasmus villemoesrasmus villemoes20.52%18.33%
andreas gruenbacherandreas gruenbacher10.26%18.33%
Total388100.00%12100.00%


static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data) { const struct cred *cred = current_cred(); struct common_audit_data ad; int rc; rc = superblock_doinit(sb, data); if (rc) return rc; /* Allow all mounts performed by the kernel */ if (flags & MS_KERNMOUNT) return 0; ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = sb->s_root; return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5966.29%222.22%
james morrisjames morris1314.61%222.22%
david howellsdavid howells1011.24%111.11%
eric pariseric paris66.74%333.33%
thomas liuthomas liu11.12%111.11%
Total89100.00%9100.00%


static int selinux_sb_statfs(struct dentry *dentry) { const struct cred *cred = current_cred(); struct common_audit_data ad; 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); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3256.14%114.29%
david howellsdavid howells1831.58%228.57%
eric pariseric paris610.53%342.86%
thomas liuthomas liu11.75%114.29%
Total57100.00%7100.00%


static int selinux_mount(const char *dev_name, const struct path *path, const char *type, unsigned long flags, void *data) { const struct cred *cred = current_cred(); if (flags & MS_REMOUNT) return superblock_has_perm(cred, path->dentry->d_sb, FILESYSTEM__REMOUNT, NULL); else return path_has_perm(cred, path, FILE__MOUNTON); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5069.44%112.50%
david howellsdavid howells1115.28%112.50%
al viroal viro811.11%450.00%
jan blunckjan blunck22.78%112.50%
eric pariseric paris11.39%112.50%
Total72100.00%8100.00%


static int selinux_umount(struct vfsmount *mnt, int flags) { const struct cred *cred = current_cred(); return superblock_has_perm(cred, mnt->mnt_sb, FILESYSTEM__UNMOUNT, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2772.97%150.00%
david howellsdavid howells1027.03%150.00%
Total37100.00%2100.00%

/* inode security operations */
static int selinux_inode_alloc_security(struct inode *inode) { return inode_alloc_security(inode); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton17100.00%1100.00%
Total17100.00%1100.00%


static void selinux_inode_free_security(struct inode *inode) { inode_free_security(inode); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton16100.00%1100.00%
Total16100.00%1100.00%


static int selinux_dentry_init_security(struct dentry *dentry, int mode, struct qstr *name, void **ctx, u32 *ctxlen) { u32 newsid; int rc; rc = selinux_determine_inode_label(d_inode(dentry->d_parent), name, inode_mode_to_security_class(mode), &newsid); if (rc) return rc; return security_sid_to_context(newsid, (char **)ctx, ctxlen); }

Contributors

PersonTokensPropCommitsCommitProp
david quigleydavid quigley7191.03%150.00%
david howellsdavid howells78.97%150.00%
Total78100.00%2100.00%


static int selinux_inode_init_security(struct inode *inode, struct inode *dir, const struct qstr *qstr, const char **name, void **value, size_t *len) { const struct task_security_struct *tsec = current_security(); struct superblock_security_struct *sbsec; u32 sid, newsid, clen; int rc; char *context; sbsec = dir->i_sb->s_security; sid = tsec->sid; newsid = tsec->create_sid; rc = selinux_determine_inode_label( dir, qstr, inode_mode_to_security_class(inode->i_mode), &newsid); if (rc) return rc; /* Possibly defer initialization to selinux_complete_init. */ if (sbsec->flags & SE_SBINITIALIZED) { struct inode_security_struct *isec = inode->i_security; isec->sclass = inode_mode_to_security_class(inode->i_mode); isec->sid = newsid; isec->initialized = LABEL_INITIALIZED; } if (!ss_initialized || !(sbsec->flags & SBLABEL_MNT)) return -EOPNOTSUPP; if (name) *name = XATTR_SELINUX_SUFFIX; if (value && len) { rc = security_sid_to_context_force(newsid, &context, &clen); if (rc) return rc; *value = context; *len = clen; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley15569.82%533.33%
eric pariseric paris4218.92%320.00%
david howellsdavid howells125.41%213.33%
david p. quigleydavid p. quigley83.60%213.33%
paul moorepaul moore20.90%16.67%
tetsuo handatetsuo handa20.90%16.67%
andreas gruenbacherandreas gruenbacher10.45%16.67%
Total222100.00%15100.00%


static int selinux_inode_create(struct inode *dir, struct dentry *dentry, umode_t mode) { return may_create(dir, dentry, SECCLASS_FILE); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2793.10%150.00%
al viroal viro26.90%150.00%
Total29100.00%2100.00%


static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry) { return may_link(dir, old_dentry, MAY_LINK); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton31100.00%1100.00%
Total31100.00%1100.00%


static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry) { return may_link(dir, dentry, MAY_UNLINK); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton26100.00%1100.00%
Total26100.00%1100.00%


static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name) { return may_create(dir, dentry, SECCLASS_LNK_FILE); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton31100.00%1100.00%
Total31100.00%1100.00%


static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, umode_t mask) { return may_create(dir, dentry, SECCLASS_DIR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2896.55%150.00%
al viroal viro13.45%150.00%
Total29100.00%2100.00%


static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry) { return may_link(dir, dentry, MAY_RMDIR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton26100.00%1100.00%
Total26100.00%1100.00%


static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev) { return may_create(dir, dentry, inode_mode_to_security_class(mode)); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3497.14%150.00%
al viroal viro12.86%150.00%
Total35100.00%2100.00%


static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry, struct inode *new_inode, struct dentry *new_dentry) { return may_rename(old_inode, old_dentry, new_inode, new_dentry); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton38100.00%1100.00%
Total38100.00%1100.00%


static int selinux_inode_readlink(struct dentry *dentry) { const struct cred *cred = current_cred(); return dentry_has_perm(cred, dentry, FILE__READ); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2066.67%150.00%
david howellsdavid howells1033.33%150.00%
Total30100.00%2100.00%


static int selinux_inode_follow_link(struct dentry *dentry, struct inode *inode, bool rcu) { const struct cred *cred = current_cred(); struct common_audit_data ad; struct inode_security_struct *isec; u32 sid; validate_creds(cred); ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = dentry; sid = cred_sid(cred); isec = inode_security_rcu(inode, rcu); if (IS_ERR(isec)) return PTR_ERR(isec); return avc_has_perm_flags(sid, isec->sid, isec->sclass, FILE__READ, &ad, rcu ? MAY_NOT_BLOCK : 0); }

Contributors

PersonTokensPropCommitsCommitProp
neil brownneil brown6860.18%120.00%
andreas gruenbacherandreas gruenbacher1815.93%240.00%
andrew mortonandrew morton1715.04%120.00%
david howellsdavid howells108.85%120.00%
Total113100.00%5100.00%


static noinline int audit_inode_permission(struct inode *inode, u32 perms, u32 audited, u32 denied, int result, unsigned flags) { struct common_audit_data ad; struct inode_security_struct *isec = inode->i_security; int rc; ad.type = LSM_AUDIT_DATA_INODE; ad.u.inode = inode; rc = slow_avc_audit(current_sid(), isec->sid, isec->sclass, perms, audited, denied, result, &ad, flags); if (rc) return rc; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris9194.79%375.00%
stephen d. smalleystephen d. smalley55.21%125.00%
Total96100.00%4100.00%


static int selinux_inode_permission(struct inode *inode, int mask) { const struct cred *cred = current_cred(); u32 perms; bool from_access; unsigned flags = mask & MAY_NOT_BLOCK; struct inode_security_struct *isec; u32 sid; struct av_decision avd; int rc, rc2; u32 audited, denied; from_access = mask & MAY_ACCESS; mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND); /* No permission to check. Existence test. */ if (!mask) return 0; validate_creds(cred); if (unlikely(IS_PRIVATE(inode))) return 0; perms = file_mask_to_av(inode->i_mode, mask); sid = cred_sid(cred); isec = inode_security_rcu(inode, flags & MAY_NOT_BLOCK); if (IS_ERR(isec)) return PTR_ERR(isec); rc = avc_has_perm_noaudit(sid, isec->sid, isec->sclass, perms, 0, &avd); audited = avc_audit_required(perms, &avd, rc, from_access ? FILE__AUDIT_ACCESS : 0, &denied); if (likely(!audited)) return rc; rc2 = audit_inode_permission(inode, perms, audited, denied, rc, flags); if (rc2) return rc2; return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris15970.35%646.15%
andrew mortonandrew morton2912.83%17.69%
andreas gruenbacherandreas gruenbacher208.85%215.38%
david howellsdavid howells93.98%17.69%
al viroal viro73.10%215.38%
stephen d. smalleystephen d. smalley20.88%17.69%
Total226100.00%13100.00%


static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr) { const struct cred *cred = current_cred(); unsigned int ia_valid = iattr->ia_valid; __u32 av = FILE__WRITE; /* 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 | ATTR_FORCE); if (!ia_valid) return 0; } if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_ATIME_SET | ATTR_MTIME_SET | ATTR_TIMES_SET)) return dentry_has_perm(cred, dentry, FILE__SETATTR); if (selinux_policycap_openperm && (ia_valid & ATTR_SIZE) && !(ia_valid & ATTR_FILE)) av |= FILE__OPEN; return dentry_has_perm(cred, dentry, av); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4938.58%114.29%
americo wangamerico wang3124.41%114.29%
eric pariseric paris2015.75%228.57%
david howellsdavid howells118.66%114.29%
stephen d. smalleystephen d. smalley97.09%114.29%
jeff vander stoepjeff vander stoep75.51%114.29%
Total127100.00%7100.00%


static int selinux_inode_getattr(const struct path *path) { return path_has_perm(current_cred(), path, FILE__GETATTR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1252.17%125.00%
al viroal viro521.74%125.00%
eric pariseric paris417.39%125.00%
david howellsdavid howells28.70%125.00%
Total23100.00%4100.00%


static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name) { const struct cred *cred = current_cred(); if (!strncmp(name, XATTR_SECURITY_PREFIX, sizeof XATTR_SECURITY_PREFIX - 1)) { if (!strcmp(name, XATTR_NAME_CAPS)) { if (!capable(CAP_SETFCAP)) return -EPERM; } else if (!capable(CAP_SYS_ADMIN)) { /* A different attribute in the security namespace. Restrict to administrator. */ return -EPERM; } } /* Not an attribute we recognize, so just check the ordinary setattr permission. */ return dentry_has_perm(cred, dentry, FILE__SETATTR); }

Contributors

PersonTokensPropCommitsCommitProp
serge hallynserge hallyn8288.17%133.33%
david howellsdavid howells1111.83%266.67%
Total93100.00%3100.00%


static int selinux_inode_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags) { struct inode *inode = d_backing_inode(dentry); struct inode_security_struct *isec; struct superblock_security_struct *sbsec; struct common_audit_data ad; u32 newsid, sid = current_sid(); int rc = 0; if (strcmp(name, XATTR_NAME_SELINUX)) return selinux_inode_setotherxattr(dentry, name); sbsec = inode->i_sb->s_security; if (!(sbsec->flags & SBLABEL_MNT)) return -EOPNOTSUPP; if (!inode_owner_or_capable(inode)) return -EPERM; ad.type = LSM_AUDIT_DATA_DENTRY; ad.u.dentry = dentry; isec = backing_inode_security(dentry); rc = avc_has_perm(sid, isec->sid, isec->sclass, FILE__RELABELFROM, &ad); if (rc) return rc; rc = security_context_to_sid(value, size, &newsid, GFP_KERNEL); if (rc == -EINVAL) { if (!capable(CAP_MAC_ADMIN)) { struct audit_buffer *ab; size_t audit_size; const char *str; /* We strip a nul only if it is at the end, otherwise the * context contains a nul and we should audit that */ if (value) { str = value; if (str[size - 1] == '\0') audit_size = size - 1; else audit_size = size; } else { str = ""; audit_size = 0; } ab = audit_log_start(current->audit_context, GFP_ATOMIC, AUDIT_SELINUX_ERR); audit_log_format(ab, "op=setxattr invalid_context="); audit_log_n_untrustedstring(ab, value, audit_size); audit_log_end(ab); return rc; } rc = security_context_to_sid_force(value, size, &newsid); } if (rc) return rc; rc = avc_has_perm(sid, newsid, isec->sclass, FILE__RELABELTO, &ad); if (rc) return rc; rc = security_validate_transition(isec->sid, newsid, sid, isec->sclass); if (rc) return rc; return avc_has_perm(newsid, sbsec->sid, SECCLASS_FILESYSTEM, FILESYSTEM__ASSOCIATE, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton18148.14%313.64%
eric pariseric paris8322.07%522.73%
stephen d. smalleystephen d. smalley4211.17%29.09%
darrel goeddeldarrel goeddel246.38%14.55%
al viroal viro174.52%14.55%
david howellsdavid howells102.66%313.64%
paul moorepaul moore71.86%14.55%
david p. quigleydavid p. quigley51.33%14.55%
serge hallynserge hallyn30.80%29.09%
nikolay aleksandrovnikolay aleksandrov20.53%14.55%
satyam sharmasatyam sharma10.27%14.55%
thomas liuthomas liu10.27%14.55%
Total376100.00%22100.00%


static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags) { struct inode *inode = d_backing_inode(dentry); struct inode_security_struct *isec; u32 newsid; int rc; if (strcmp(name, XATTR_NAME_SELINUX)) { /* Not an attribute we recognize, so nothing to do. */ return; } rc = security_context_to_sid_force(value, size, &newsid); if (rc) { printk(KERN_ERR "SELinux: unable to map context to SID" "for (%s, %lu), rc=%d\n", inode->i_sb->s_id, inode->i_ino, -rc); return; } isec = backing_inode_security(dentry); isec->sclass = inode_mode_to_security_class(inode->i_mode); isec->sid = newsid; isec->initialized = LABEL_INITIALIZED; return; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton9068.70%114.29%
david quigleydavid quigley1612.21%114.29%
stephen d. smalleystephen d. smalley129.16%114.29%
paul moorepaul moore75.34%114.29%
david howellsdavid howells53.82%228.57%
andreas gruenbacherandreas gruenbacher10.76%114.29%
Total131100.00%7100.00%


static int selinux_inode_getxattr(struct dentry *dentry, const char *name) { const struct cred *cred = current_cred(); return dentry_has_perm(cred, dentry, FILE__GETATTR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2468.57%133.33%
david howellsdavid howells1131.43%266.67%
Total35100.00%3100.00%


static int selinux_inode_listxattr(struct dentry *dentry) { const struct cred *cred = current_cred(); return dentry_has_perm(cred, dentry, FILE__GETATTR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2066.67%150.00%
david howellsdavid howells1033.33%150.00%
Total30100.00%2100.00%


static int selinux_inode_removexattr(struct dentry *dentry, const char *name) { if (strcmp(name, XATTR_NAME_SELINUX)) return selinux_inode_setotherxattr(dentry, name); /* No one is allowed to remove a SELinux security label. You can change the label, but all data must be labeled. */ return -EACCES; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3592.11%133.33%
serge hallynserge hallyn25.26%133.33%
david howellsdavid howells12.63%133.33%
Total38100.00%3100.00%

/* * Copy the inode security context value to the user. * * Permission check is handled by selinux_inode_getxattr hook. */
static int selinux_inode_getsecurity(struct inode *inode, const char *name, void **buffer, bool alloc) { u32 size; int error; char *context = NULL; struct inode_security_struct *isec; if (strcmp(name, XATTR_SELINUX_SUFFIX)) return -EOPNOTSUPP; /* * If the caller has CAP_MAC_ADMIN, then get the raw context * value even if it is not defined by current policy; otherwise, * use the in-core value under current policy. * Use the non-auditing forms of the permission checks since * getxattr may be called by unprivileged processes commonly * and lack of permission just means that we fall back to the * in-core context value, not a denial. */ error = cap_capable(current_cred(), &init_user_ns, CAP_MAC_ADMIN, SECURITY_CAP_NOAUDIT); if (!error) error = cred_has_capability(current_cred(), CAP_MAC_ADMIN, SECURITY_CAP_NOAUDIT, true); isec = inode_security(inode); if (!error) error = security_sid_to_context_force(isec->sid, &context, &size); else error = security_sid_to_context(isec->sid, &context, &size); if (error) return error; error = size; if (alloc) { *buffer = context; goto out_nofree; } kfree(context); out_nofree: return error; }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley5633.53%18.33%
andrew mortonandrew morton4225.15%18.33%
stephen d. smalleystephen d. smalley3017.96%216.67%
casey schauflercasey schaufler2011.98%18.33%
paul moorepaul moore52.99%18.33%
james morrisjames morris42.40%216.67%
serge hallynserge hallyn31.80%18.33%
david howellsdavid howells31.80%18.33%
eric pariseric paris21.20%18.33%
dustin kirklanddustin kirkland21.20%18.33%
Total167100.00%12100.00%


static int selinux_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags) { struct inode_security_struct *isec = inode_security_novalidate(inode); u32 newsid; int rc; if (strcmp(name, XATTR_SELINUX_SUFFIX)) return -EOPNOTSUPP; if (!value || !size) return -EACCES; rc = security_context_to_sid(value, size, &newsid, GFP_KERNEL); if (rc) return rc; isec->sclass = inode_mode_to_security_class(inode->i_mode); isec->sid = newsid; isec->initialized = LABEL_INITIALIZED; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton9179.13%112.50%
david quigleydavid quigley119.57%112.50%
david p. quigleydavid p. quigley54.35%112.50%
andreas gruenbacherandreas gruenbacher32.61%225.00%
nikolay aleksandrovnikolay aleksandrov21.74%112.50%
james morrisjames morris21.74%112.50%
paul moorepaul moore10.87%112.50%
Total115100.00%8100.00%


static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size) { const int len = sizeof(XATTR_NAME_SELINUX); if (buffer && len <= buffer_size) memcpy(buffer, XATTR_NAME_SELINUX, len); return len; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3880.85%150.00%
james morrisjames morris919.15%150.00%
Total47100.00%2100.00%


static void selinux_inode_getsecid(struct inode *inode, u32 *secid) { struct inode_security_struct *isec = inode_security_novalidate(inode); *secid = isec->sid; }

Contributors

PersonTokensPropCommitsCommitProp
ahmed s. darwishahmed s. darwish2990.62%133.33%
andreas gruenbacherandreas gruenbacher39.38%266.67%
Total32100.00%3100.00%

/* file security operations */
static int selinux_revalidate_file_permission(struct file *file, int mask) { const struct cred *cred = current_cred(); struct inode *inode = file_inode(file); /* file_mask_to_av won't add FILE__WRITE if MAY_APPEND is set */ if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE)) mask |= MAY_APPEND; return file_has_perm(cred, file, file_mask_to_av(inode->i_mode, mask)); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5678.87%120.00%
david howellsdavid howells1014.08%120.00%
al viroal viro34.23%120.00%
paul moorepaul moore11.41%120.00%
yuichi nakamurayuichi nakamura11.41%120.00%
Total71100.00%5100.00%


static int selinux_file_permission(struct file *file, int mask) { struct inode *inode = file_inode(file); struct file_security_struct *fsec = file->f_security; struct inode_security_struct *isec; u32 sid = current_sid(); if (!mask) /* No permission to check. Existence test. */ return 0; isec = inode_security(inode); if (sid == fsec->sid && fsec->isid == isec->sid && fsec->pseqno == avc_policy_seqno()) /* No change since file_open check. */ return 0; return selinux_revalidate_file_permission(file, mask); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley5355.79%120.00%
yuichi nakamurayuichi nakamura3132.63%120.00%
andreas gruenbacherandreas gruenbacher77.37%120.00%
al viroal viro33.16%120.00%
eric pariseric paris11.05%120.00%
Total95100.00%5100.00%


static int selinux_file_alloc_security(struct file *file) { return file_alloc_security(file); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton17100.00%1100.00%
Total17100.00%1100.00%


static void selinux_file_free_security(struct file *file) { file_free_security(file); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton16100.00%1100.00%
Total16100.00%1100.00%

/* * Check whether a task has the ioctl permission and cmd * operation to an inode. */
static int ioctl_has_perm(const struct cred *cred, struct file *file, u32 requested, u16 cmd) { struct common_audit_data ad; struct file_security_struct *fsec = file->f_security; struct inode *inode = file_inode(file); struct inode_security_struct *isec; struct lsm_ioctlop_audit ioctl; u32 ssid = cred_sid(cred); int rc; u8 driver = cmd >> 8; u8 xperm = cmd & 0xff; ad.type = LSM_AUDIT_DATA_IOCTL_OP; ad.u.op = &ioctl; ad.u.op->cmd = cmd; ad.u.op->path = file->f_path; if (ssid != fsec->sid) { rc = avc_has_perm(ssid, fsec->sid, SECCLASS_FD, FD__USE, &ad); if (rc) goto out; } if (unlikely(IS_PRIVATE(inode))) return 0; isec = inode_security(inode); rc = avc_has_extended_perms(ssid, isec->sid, isec->sclass, requested, driver, xperm, &ad); out: return rc; }

Contributors

PersonTokensPropCommitsCommitProp
jeff vander stoepjeff vander stoep19396.02%133.33%
paul moorepaul moore73.48%133.33%
geliang tanggeliang tang10.50%133.33%
Total201100.00%3100.00%


static int selinux_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { const struct cred *cred = current_cred(); int error = 0; switch (cmd) { case FIONREAD: /* fall through */ case FIBMAP: /* fall through */ case FIGETBSZ: /* fall through */ case FS_IOC_GETFLAGS: /* fall through */ case FS_IOC_GETVERSION: error = file_has_perm(cred, file, FILE__GETATTR); break; case FS_IOC_SETFLAGS: /* fall through */ case FS_IOC_SETVERSION: error = file_has_perm(cred, file, FILE__SETATTR); break; /* sys_ioctl() checks */ case FIONBIO: /* fall through */ case FIOASYNC: error = file_has_perm(cred, file, 0); break; case KDSKBENT: case KDSKBSENT: error = cred_has_capability(cred, CAP_SYS_TTY_CONFIG, SECURITY_CAP_AUDIT, true); break; /* default case assumes that the command will go * to the file's ioctl() function. */ default: error = ioctl_has_perm(cred, file, FILE__IOCTL, (u16) cmd); } return error; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris9060.00%222.22%
andrew mortonandrew morton3624.00%222.22%
david howellsdavid howells106.67%111.11%
jeff vander stoepjeff vander stoep64.00%111.11%
stephen d. smalleystephen d. smalley42.67%222.22%
al viroal viro42.67%111.11%
Total150100.00%9100.00%

static int default_noexec;
static int file_map_prot_check(struct file *file, unsigned long prot, int shared) { const struct cred *cred = current_cred(); int rc = 0; if (default_noexec && (prot & PROT_EXEC) && (!file || IS_PRIVATE(file_inode(file)) || (!shared && (prot & PROT_WRITE)))) { /* * We are making executable an anonymous mapping or a * private file mapping that will also be writable. * This has an additional check. */ rc = cred_has_perm(cred, cred, PROCESS__EXECMEM); if (rc) goto error; } if (file) { /* read access is always possible with a mapping */ u32 av = FILE__READ; /* write access only matters if the mapping is shared */ if (shared && (prot & PROT_WRITE)) av |= FILE__WRITE; if (prot & PROT_EXEC) av |= FILE__EXECUTE; return file_has_perm(cred, file, av); } error: return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5942.45%114.29%
stephen d. smalleystephen d. smalley4733.81%342.86%
david howellsdavid howells2618.71%228.57%
james morrisjames morris75.04%114.29%
Total139100.00%7100.00%


static int selinux_mmap_addr(unsigned long addr) { int rc = 0; if (addr < CONFIG_LSM_MMAP_MIN_ADDR) { u32 sid = current_sid(); rc = avc_has_perm(sid, sid, SECCLASS_MEMPROTECT, MEMPROTECT__MMAP_ZERO, NULL); } return rc; }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris1940.43%337.50%
james morrisjames morris1531.91%112.50%
paul moorepaul moore714.89%112.50%
al viroal viro36.38%112.50%
casey schauflercasey schaufler24.26%112.50%
stephen d. smalleystephen d. smalley12.13%112.50%
Total47100.00%8100.00%


static int selinux_mmap_file(struct file *file, unsigned long reqprot, unsigned long prot, unsigned long flags) { if (selinux_checkreqprot) prot = reqprot; return file_map_prot_check(file, prot, (flags & MAP_TYPE) == MAP_SHARED); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro2246.81%133.33%
james morrisjames morris1736.17%133.33%
stephen d. smalleystephen d. smalley817.02%133.33%
Total47100.00%3100.00%


static int selinux_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot, unsigned long prot) { const struct cred *cred = current_cred(); if (selinux_checkreqprot) prot = reqprot; if (default_noexec && (prot & PROT_EXEC) && !(vma->vm_flags & VM_EXEC)) { int rc = 0; if (vma->vm_start >= vma->vm_mm->start_brk && vma->vm_end <= vma->vm_mm->brk) { rc = cred_has_perm(cred, cred, PROCESS__EXECHEAP); } else if (!vma->vm_file && ((vma->vm_start <= vma->vm_mm->start_stack && vma->vm_end >= vma->vm_mm->start_stack) || vma_is_stack_for_task(vma, current))) { rc = current_has_perm(current, PROCESS__EXECSTACK); } else if (vma->vm_file && vma->anon_vma) { /* * We are making executable a file mapping that has * had some COW done. Since pages might have been * written, check ability to execute the possibly * modified content. This typically should only * occur for text relocations. */ rc = file_has_perm(cred, vma->vm_file, FILE__EXECMOD); } if (rc) return rc; } return file_map_prot_check(vma->vm_file, prot, vma->vm_flags&VM_SHARED); }

Contributors

PersonTokensPropCommitsCommitProp
lorenzo hernandez garcia-hierrolorenzo hernandez garcia-hierro8643.65%215.38%
stephen d. smalleystephen d. smalley6331.98%538.46%
andrew mortonandrew morton2814.21%17.69%
david howellsdavid howells147.11%323.08%
james morrisjames morris63.05%215.38%
Total197100.00%13100.00%


static int selinux_file_lock(struct file *file, unsigned int cmd) { const struct cred *cred = current_cred(); return file_has_perm(cred, file, FILE__LOCK); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2470.59%150.00%
david howellsdavid howells1029.41%150.00%
Total34100.00%2100.00%


static int selinux_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg) { const struct cred *cred = current_cred(); int err = 0; switch (cmd) { case F_SETFL: if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) { err = file_has_perm(cred, file, FILE__WRITE); break; } /* fall through */ case F_SETOWN: case F_SETSIG: case F_GETFL: case F_GETOWN: case F_GETSIG: case F_GETOWNER_UIDS: /* Just check FD__USE permission */ err = file_has_perm(cred, file, 0); break; case F_GETLK: case F_SETLK: case F_SETLKW: case F_OFD_GETLK: case F_OFD_SETLK: case F_OFD_SETLKW: #if BITS_PER_LONG == 32 case F_GETLK64: case F_SETLK64: case F_SETLKW64: #endif err = file_has_perm(cred, file, FILE__LOCK); break; } return err; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton13084.42%233.33%
david howellsdavid howells127.79%116.67%
jeff laytonjeff layton95.84%233.33%
cyrill gorcunovcyrill gorcunov31.95%116.67%
Total154100.00%6100.00%


static void selinux_file_set_fowner(struct file *file) { struct file_security_struct *fsec; fsec = file->f_security; fsec->fown_sid = current_sid(); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2689.66%133.33%
david howellsdavid howells26.90%133.33%
jeff laytonjeff layton13.45%133.33%
Total29100.00%3100.00%


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; /* struct fown_struct is never outside the context of a struct file */ file = container_of(fown, struct file, f_owner); fsec = file->f_security; if (!signum) perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */ else perm = signal_to_av(signum); return avc_has_perm(fsec->fown_sid, sid, SECCLASS_PROCESS, perm, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton8487.50%120.00%
david howellsdavid howells44.17%120.00%
stephen d. smalleystephen d. smalley44.17%120.00%
robert p. j. dayrobert p. j. day33.12%120.00%
chris wrightchris wright11.04%120.00%
Total96100.00%5100.00%


static int selinux_file_receive(struct file *file) { const struct cred *cred = current_cred(); return file_has_perm(cred, file, file_to_av(file)); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2369.70%150.00%
david howellsdavid howells1030.30%150.00%
Total33100.00%2100.00%


static int selinux_file_open(struct file *file, const struct cred *cred) { struct file_security_struct *fsec; struct inode_security_struct *isec; fsec = file->f_security; isec = inode_security(file_inode(file)); /* * Save inode label and policy sequence number * at open-time so that selinux_file_permission * can determine whether revalidation is necessary. * Task label is already saved in the file security * struct as its SID. */ fsec->isid = isec->sid; fsec->pseqno = avc_policy_seqno(); /* * Since the inode label or policy seqno may have changed * between the selinux_inode_permission check and the saving * of state above, recheck that access is still permitted. * Otherwise, access might never be revalidated against the * new inode label or new policy. * This check is not redundant - do not remove. */ return file_path_has_perm(cred, file, open_file_to_av(file)); }

Contributors

PersonTokensPropCommitsCommitProp
yuichi nakamurayuichi nakamura5372.60%111.11%
david howellsdavid howells1013.70%333.33%
eric pariseric paris45.48%333.33%
al viroal viro34.11%111.11%
andreas gruenbacherandreas gruenbacher34.11%111.11%
Total73100.00%9100.00%

/* task security operations */
static int selinux_task_create(unsigned long clone_flags) { return current_has_perm(current, PROCESS__FORK); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1794.44%150.00%
david howellsdavid howells15.56%150.00%
Total18100.00%2100.00%

/* * allocate the SELinux part of blank credentials */
static int selinux_cred_alloc_blank(struct cred *cred, gfp_t gfp) { struct task_security_struct *tsec; tsec = kzalloc(sizeof(struct task_security_struct), gfp); if (!tsec) return -ENOMEM; cred->security = tsec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells50100.00%1100.00%
Total50100.00%1100.00%

/* * detach and free the LSM part of a set of credentials */
static void selinux_cred_free(struct cred *cred) { struct task_security_struct *tsec = cred->security; /* * cred->security == NULL if security_cred_alloc_blank() or * security_prepare_creds() returned an error. */ BUG_ON(cred->security && (unsigned long) cred->security < PAGE_SIZE); cred->security = (void *) 0x7UL; kfree(tsec); }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells3464.15%466.67%
andrew mortonandrew morton1426.42%116.67%
tetsuo handatetsuo handa59.43%116.67%
Total53100.00%6100.00%

/* * prepare a new set of credentials for modification */
static int selinux_cred_prepare(struct cred *new, const struct cred *old, gfp_t gfp) { const struct task_security_struct *old_tsec; struct task_security_struct *tsec; old_tsec = old->security; tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp); if (!tsec) return -ENOMEM; new->security = tsec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells5882.86%125.00%
andrew mortonandrew morton710.00%125.00%
michael lemaymichael lemay34.29%125.00%
eric pariseric paris22.86%125.00%
Total70100.00%4100.00%

/* * transfer the SELinux data to a blank set of creds */
static void selinux_cred_transfer(struct cred *new, const struct cred *old) { const struct task_security_struct *old_tsec = old->security; struct task_security_struct *tsec = new->security; *tsec = *old_tsec; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells42100.00%1100.00%
Total42100.00%1100.00%

/* * set the security data for a kernel service * - all the creation contexts are set to unlabelled */
static int selinux_kernel_act_as(struct cred *new, u32 secid) { struct task_security_struct *tsec = new->security; u32 sid = current_sid(); int ret; ret = avc_has_perm(sid, secid, SECCLASS_KERNEL_SERVICE, KERNEL_SERVICE__USE_AS_OVERRIDE, NULL); if (ret == 0) { tsec->sid = secid; tsec->create_sid = 0; tsec->keycreate_sid = 0; tsec->sockcreate_sid = 0; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells82100.00%1100.00%
Total82100.00%1100.00%

/* * set the file creation context in a security record to the same as the * objective context of the specified inode */
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 = new->security; u32 sid = current_sid(); int ret; ret = avc_has_perm(sid, isec->sid, SECCLASS_KERNEL_SERVICE, KERNEL_SERVICE__CREATE_FILES_AS, NULL); if (ret == 0) tsec->create_sid = isec->sid; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells7596.15%266.67%
andreas gruenbacherandreas gruenbacher33.85%133.33%
Total78100.00%3100.00%


static int selinux_kernel_module_request(char *kmod_name) { u32 sid; struct common_audit_data ad; sid = task_sid(current); ad.type = LSM_AUDIT_DATA_KMOD; ad.u.kmod_name = kmod_name; return avc_has_perm(sid, SECINITSID_KERNEL, SECCLASS_SYSTEM, SYSTEM__MODULE_REQUEST, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris53100.00%5100.00%
Total53100.00%5100.00%


static int selinux_kernel_module_from_file(struct file *file) { struct common_audit_data ad; struct inode_security_struct *isec; struct file_security_struct *fsec; u32 sid = current_sid(); int rc; /* init_module */ if (file == NULL) return avc_has_perm(sid, sid, SECCLASS_SYSTEM, SYSTEM__MODULE_LOAD, NULL); /* finit_module */ ad.type = LSM_AUDIT_DATA_PATH; ad.u.path = file->f_path; fsec = file->f_security; if (sid != fsec->sid) { rc = avc_has_perm(sid, fsec->sid, SECCLASS_FD, FD__USE, &ad); if (rc) return rc; } isec = inode_security(file_inode(file)); return avc_has_perm(sid, isec->sid, SECCLASS_SYSTEM, SYSTEM__MODULE_LOAD, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
jeff vander stoepjeff vander stoep13092.86%150.00%
paul moorepaul moore107.14%150.00%
Total140100.00%2100.00%


static int selinux_kernel_read_file(struct file *file, enum kernel_read_file_id id) { int rc = 0; switch (id) { case READING_MODULE: rc = selinux_kernel_module_from_file(file); break; default: break; } return rc; }

Contributors

PersonTokensPropCommitsCommitProp
jeff vander stoepjeff vander stoep42100.00%1100.00%
Total42100.00%1100.00%


static int selinux_task_setpgid(struct task_struct *p, pid_t pgid) { return current_has_perm(p, PROCESS__SETPGID); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2195.45%150.00%
david howellsdavid howells14.55%150.00%
Total22100.00%2100.00%


static int selinux_task_getpgid(struct task_struct *p) { return current_has_perm(p, PROCESS__GETPGID); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1894.74%150.00%
david howellsdavid howells15.26%150.00%
Total19100.00%2100.00%


static int selinux_task_getsid(struct task_struct *p) { return current_has_perm(p, PROCESS__GETSESSION); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1894.74%150.00%
david howellsdavid howells15.26%150.00%
Total19100.00%2100.00%


static void selinux_task_getsecid(struct task_struct *p, u32 *secid) { *secid = task_sid(p); }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley1773.91%133.33%
david howellsdavid howells417.39%133.33%
ahmed s. darwishahmed s. darwish28.70%133.33%
Total23100.00%3100.00%


static int selinux_task_setnice(struct task_struct *p, int nice) { return current_has_perm(p, PROCESS__SETSCHED); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2195.45%150.00%
david howellsdavid howells14.55%150.00%
Total22100.00%2100.00%


static int selinux_task_setioprio(struct task_struct *p, int ioprio) { return current_has_perm(p, PROCESS__SETSCHED); }

Contributors

PersonTokensPropCommitsCommitProp
james morrisjames morris2195.45%150.00%
david howellsdavid howells14.55%150.00%
Total22100.00%2100.00%


static int selinux_task_getioprio(struct task_struct *p) { return current_has_perm(p, PROCESS__GETSCHED); }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley1894.74%150.00%
david howellsdavid howells15.26%150.00%
Total19100.00%2100.00%


static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource, struct rlimit *new_rlim) { struct rlimit *old_rlim = p->signal->rlim + resource; /* 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 upon context transitions. See selinux_bprm_committing_creds. */ if (old_rlim->rlim_max != new_rlim->rlim_max) return current_has_perm(p, PROCESS__SETRLIMIT); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4480.00%233.33%
jiri slabyjiri slaby712.73%116.67%
roland mcgrathroland mcgrath23.64%116.67%
david howellsdavid howells23.64%233.33%
Total55100.00%6100.00%


static int selinux_task_setscheduler(struct task_struct *p) { return current_has_perm(p, PROCESS__SETSCHED); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1789.47%133.33%
stephen d. smalleystephen d. smalley15.26%133.33%
david howellsdavid howells15.26%133.33%
Total19100.00%3100.00%


static int selinux_task_getscheduler(struct task_struct *p) { return current_has_perm(p, PROCESS__GETSCHED); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1894.74%150.00%
david howellsdavid howells15.26%150.00%
Total19100.00%2100.00%


static int selinux_task_movememory(struct task_struct *p) { return current_has_perm(p, PROCESS__SETSCHED); }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley1894.74%150.00%
david howellsdavid howells15.26%150.00%
Total19100.00%2100.00%


static int selinux_task_kill(struct task_struct *p, struct siginfo *info, int sig, u32 secid) { u32 perm; int rc; if (!sig) perm = PROCESS__SIGNULL; /* null signal; existence test */ else perm = signal_to_av(sig); if (secid) rc = avc_has_perm(secid, task_sid(p), SECCLASS_PROCESS, perm, NULL); else rc = current_has_perm(p, perm); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4960.49%240.00%
david p. quigleydavid p. quigley2733.33%120.00%
david howellsdavid howells56.17%240.00%
Total81100.00%5100.00%


static int selinux_task_wait(struct task_struct *p) { return task_has_perm(p, current, PROCESS__SIGCHLD); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2095.24%150.00%
eric pariseric paris14.76%150.00%
Total21100.00%2100.00%


static void selinux_task_to_inode(struct task_struct *p, struct inode *inode) { struct inode_security_struct *isec = inode->i_security; u32 sid = task_sid(p); isec->sid = sid; isec->initialized = LABEL_INITIALIZED; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3680.00%133.33%
david howellsdavid howells817.78%133.33%
andreas gruenbacherandreas gruenbacher12.22%133.33%
Total45100.00%3100.00%

/* Returns error only if unable to parse addresses */
static int selinux_parse_skb_ipv4(struct sk_buff *skb, struct common_audit_data *ad, u8 *proto) { int offset, ihlen, ret = -EINVAL; struct iphdr _iph, *ih; offset = skb_network_offset(skb); ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph); if (ih == NULL) goto out; ihlen = ih->ihl * 4; if (ihlen < sizeof(_iph)) goto out; ad->u.net->v4info.saddr = ih->saddr; ad->u.net->v4info.daddr = ih->daddr; ret = 0; if (proto) *proto = ih->protocol; switch (ih->protocol) { case IPPROTO_TCP: { struct tcphdr _tcph, *th; if (ntohs(ih->frag_off) & IP_OFFSET) break; offset += ihlen; th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph); if (th == NULL) break; ad->u.net->sport = th->source; ad->u.net->dport = th->dest; break; } case IPPROTO_UDP: { struct udphdr _udph, *uh; if (ntohs(ih->frag_off) & IP_OFFSET) break; offset += ihlen; uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph); if (uh == NULL) break; ad->u.net->sport = uh->source; ad->u.net->dport = uh->dest; break; } case IPPROTO_DCCP: { struct dccp_hdr _dccph, *dh; if (ntohs(ih->frag_off) & IP_OFFSET) break; offset += ihlen; dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph); if (dh == NULL) break; ad->u.net->sport = dh->dccph_sport; ad->u.net->dport = dh->dccph_dport; break; } default: break; } out: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton20253.30%222.22%
james morrisjames morris7519.79%111.11%
david s. millerdavid s. miller6817.94%111.11%
venkat yekkiralavenkat yekkirala153.96%111.11%
eric pariseric paris82.11%111.11%
stephen d. smalleystephen d. smalley71.85%111.11%
arnaldo carvalho de meloarnaldo carvalho de melo30.79%111.11%
thomas liuthomas liu10.26%111.11%
Total379100.00%9100.00%

#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) /* Returns error only if unable to parse addresses */
static int selinux_parse_skb_ipv6(struct sk_buff *skb, struct common_audit_data *ad, u8 *proto) { u8 nexthdr; int ret = -EINVAL, offset; struct ipv6hdr _ipv6h, *ip6; __be16 frag_off; offset = skb_network_offset(skb); ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h); if (ip6 == NULL) goto out; ad->u.net->v6info.saddr = ip6->saddr; ad->u.net->v6info.daddr = ip6->daddr; ret = 0; nexthdr = ip6->nexthdr; offset += sizeof(_ipv6h); offset = ipv6_skip_exthdr(skb, offset, &nexthdr, &frag_off); if (offset < 0) goto out; if (proto) *proto = nexthdr; switch (nexthdr) { case IPPROTO_TCP: { struct tcphdr _tcph, *th; th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph); if (th == NULL) break; ad->u.net->sport = th->source; ad->u.net->dport = th->dest; break; } case IPPROTO_UDP: { struct udphdr _udph, *uh; uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph); if (uh == NULL) break; ad->u.net->sport = uh->source; ad->u.net->dport = uh->dest; break; } case IPPROTO_DCCP: { struct dccp_hdr _dccph, *dh; dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph); if (dh == NULL) break; ad->u.net->sport = dh->dccph_sport; ad->u.net->dport = dh->dccph_dport; break; } /* includes fragments */ default: break; } out: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton18853.87%218.18%
david s. millerdavid s. miller6217.77%19.09%
james morrisjames morris5916.91%19.09%
venkat yekkiralavenkat yekkirala133.72%19.09%
eric pariseric paris82.29%19.09%
stephen d. smalleystephen d. smalley72.01%19.09%
jesse grossjesse gross61.72%19.09%
arnaldo carvalho de meloarnaldo carvalho de melo30.86%19.09%
alexey dobriyanalexey dobriyan20.57%19.09%
thomas liuthomas liu10.29%19.09%
Total349100.00%11100.00%

#endif /* IPV6 */
static int selinux_parse_skb(struct sk_buff *skb, struct common_audit_data *ad, char **_addrp, int src, u8 *proto) { char *addrp; int ret; switch (ad->u.net->family) { case PF_INET: ret = selinux_parse_skb_ipv4(skb, ad, proto); if (ret) goto parse_error; addrp = (char *)(src ? &ad->u.net->v4info.saddr : &ad->u.net->v4info.daddr); goto okay; #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) case PF_INET6: ret = selinux_parse_skb_ipv6(skb, ad, proto); if (ret) goto parse_error; addrp = (char *)(src ? &ad->u.net->v6info.saddr : &ad->u.net->v6info.daddr); goto okay; #endif /* IPV6 */ default: addrp = NULL; goto okay; } parse_error: printk(KERN_WARNING "SELinux: failure in selinux_parse_skb()," " unable to parse packet\n"); return ret; okay: if (_addrp) *_addrp = addrp; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton14670.53%116.67%
david howellsdavid howells4019.32%116.67%
venkat yekkiralavenkat yekkirala83.86%116.67%
paul moorepaul moore73.38%116.67%
eric pariseric paris52.42%116.67%
thomas liuthomas liu10.48%116.67%
Total207100.00%6100.00%

/** * selinux_skb_peerlbl_sid - Determine the peer label of a packet * @skb: the packet * @family: protocol family * @sid: the packet's peer label SID * * Description: * Check the various different forms of network peer labeling and determine * the peer label/SID for the packet; most of the magic actually occurs in * the security server function security_net_peersid_cmp(). The function * returns zero if the value in @sid is valid (although it may be SECSID_NULL) * or -EACCES if @sid is invalid due to inconsistencies with the different * peer labels. * */
static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid) { int err; u32 xfrm_sid; u32 nlbl_sid; u32 nlbl_type; err = selinux_xfrm_skb_sid(skb, &xfrm_sid); if (unlikely(err)) return -EACCES; err = selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid); if (unlikely(err)) return -EACCES; err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid); if (unlikely(err)) { printk(KERN_WARNING "SELinux: failure in selinux_skb_peerlbl_sid()," " unable to determine packet's peer label\n"); return -EACCES; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore113100.00%6100.00%
Total113100.00%6100.00%

/** * selinux_conn_sid - Determine the child socket label for a connection * @sk_sid: the parent socket's SID * @skb_sid: the packet's SID * @conn_sid: the resulting connection SID * * If @skb_sid is valid then the user:role:type information from @sk_sid is * combined with the MLS information from @skb_sid in order to create * @conn_sid. If @skb_sid is not valid then then @conn_sid is simply a copy * of @sk_sid. Returns zero on success, negative values on failure. * */
static int selinux_conn_sid(u32 sk_sid, u32 skb_sid, u32 *conn_sid) { int err = 0; if (skb_sid != SECSID_NULL) err = security_sid_mls_copy(sk_sid, skb_sid, conn_sid); else *conn_sid = sk_sid; return err; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore47100.00%1100.00%
Total47100.00%1100.00%

/* socket security operations */
static int socket_sockcreate_sid(const struct task_security_struct *tsec, u16 secclass, u32 *socksid) { if (tsec->sockcreate_sid > SECSID_NULL) { *socksid = tsec->sockcreate_sid; return 0; } return security_transition_sid(tsec->sid, tsec->sid, secclass, NULL, socksid); }

Contributors

PersonTokensPropCommitsCommitProp
harry ciaoharry ciao3663.16%150.00%
paul moorepaul moore2136.84%150.00%
Total57100.00%2100.00%


static int sock_has_perm(struct task_struct *task, struct sock *sk, u32 perms) { struct sk_security_struct *sksec = sk->sk_security; struct common_audit_data ad; struct lsm_network_audit net = {0,}; u32 tsid = task_sid(task); if (sksec->sid == SECINITSID_KERNEL) return 0; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->sk = sk; return avc_has_perm(tsid, sksec->sid, sksec->sclass, perms, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4947.57%220.00%
eric pariseric paris2322.33%440.00%
paul moorepaul moore2120.39%110.00%
james morrisjames morris87.77%110.00%
david howellsdavid howells10.97%110.00%
thomas liuthomas liu10.97%110.00%
Total103100.00%10100.00%


static int selinux_socket_create(int family, int type, int protocol, int kern) { const struct task_security_struct *tsec = current_security(); u32 newsid; u16 secclass; int rc; if (kern) return 0; secclass = socket_type_to_security_class(family, type, protocol); rc = socket_sockcreate_sid(tsec, secclass, &newsid); if (rc) return rc; return avc_has_perm(tsec->sid, newsid, secclass, SOCKET__CREATE, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3235.96%112.50%
harry ciaoharry ciao2224.72%112.50%
david howellsdavid howells1516.85%112.50%
james morrisjames morris910.11%225.00%
paul moorepaul moore88.99%225.00%
eric pariseric paris33.37%112.50%
Total89100.00%8100.00%


static int selinux_socket_post_create(struct socket *sock, int family, int type, int protocol, int kern) { const struct task_security_struct *tsec = current_security(); struct inode_security_struct *isec = inode_security_novalidate(SOCK_INODE(sock)); struct sk_security_struct *sksec; int err = 0; isec->sclass = socket_type_to_security_class(family, type, protocol); if (kern) isec->sid = SECINITSID_KERNEL; else { err = socket_sockcreate_sid(tsec, isec->sclass, &(isec->sid)); if (err) return err; } isec->initialized = LABEL_INITIALIZED; if (sock->sk) { sksec = sock->sk->sk_security; sksec->sid = isec->sid; sksec->sclass = isec->sclass; err = selinux_netlbl_socket_post_create(sock->sk, family); } return err; }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala4025.32%212.50%
andrew mortonandrew morton3220.25%16.25%
harry ciaoharry ciao3018.99%16.25%
david howellsdavid howells2314.56%212.50%
paul moorepaul moore2213.92%425.00%
james morrisjames morris42.53%212.50%
andreas gruenbacherandreas gruenbacher42.53%318.75%
stephen d. smalleystephen d. smalley31.90%16.25%
Total158100.00%16100.00%

/* Range of port numbers used to automatically bind. Need to determine whether we should perform a name_bind permission check between the socket and the port number. */
static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen) { struct sock *sk = sock->sk; u16 family; int err; err = sock_has_perm(current, sk, SOCKET__BIND); if (err) goto out; /* * If PF_INET or PF_INET6, check name_bind permission for the port. * Multiple address binding for SCTP is not supported yet: we just * check the first address now. */ family = sk->sk_family; if (family == PF_INET || family == PF_INET6) { char *addrp; struct sk_security_struct *sksec = sk->sk_security; struct common_audit_data ad; struct lsm_network_audit net = {0,}; struct sockaddr_in *addr4 = NULL; struct sockaddr_in6 *addr6 = NULL; unsigned short snum; u32 sid, node_perm; if (family == PF_INET) { addr4 = (struct sockaddr_in *)address; snum = ntohs(addr4->sin_port); addrp = (char *)&addr4->sin_addr.s_addr; } else { addr6 = (struct sockaddr_in6 *)address; snum = ntohs(addr6->sin6_port); addrp = (char *)&addr6->sin6_addr.s6_addr; } if (snum) { int low, high; inet_get_local_port_range(sock_net(sk), &low, &high); if (snum < max(PROT_SOCK, low) || snum > high) { err = sel_netport_sid(sk->sk_protocol, snum, &sid); if (err) goto out; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->sport = htons(snum); ad.u.net->family = family; err = avc_has_perm(sksec->sid, sid, sksec->sclass, SOCKET__NAME_BIND, &ad); if (err) goto out; } } switch (sksec->sclass) { case SECCLASS_TCP_SOCKET: node_perm = TCP_SOCKET__NODE_BIND; break; case SECCLASS_UDP_SOCKET: node_perm = UDP_SOCKET__NODE_BIND; break; case SECCLASS_DCCP_SOCKET: node_perm = DCCP_SOCKET__NODE_BIND; break; default: node_perm = RAWIP_SOCKET__NODE_BIND; break; } err = sel_netnode_sid(addrp, family, &sid); if (err) goto out; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->sport = htons(snum); ad.u.net->family = family; if (family == PF_INET) ad.u.net->v4info.saddr = addr4->sin_addr.s_addr; else ad.u.net->v6info.saddr = addr6->sin6_addr; err = avc_has_perm(sksec->sid, sid, sksec->sclass, node_perm, &ad); if (err) goto out; } out: return err; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton36876.03%422.22%
eric pariseric paris428.68%422.22%
paul moorepaul moore255.17%316.67%
stephen hemmingerstephen hemminger214.34%15.56%
james morrisjames morris122.48%211.11%
stephen d. smalleystephen d. smalley91.86%15.56%
eric w. biedermaneric w. biederman51.03%15.56%
thomas liuthomas liu10.21%15.56%
alexey dobriyanalexey dobriyan10.21%15.56%
Total484100.00%18100.00%


static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen) { struct sock *sk = sock->sk; struct sk_security_struct *sksec = sk->sk_security; int err; err = sock_has_perm(current, sk, SOCKET__CONNECT); if (err) return err; /* * If a TCP or DCCP socket, check name_connect permission for the port. */ if (sksec->sclass == SECCLASS_TCP_SOCKET || sksec->sclass == SECCLASS_DCCP_SOCKET) { struct common_audit_data ad; struct lsm_network_audit net = {0,}; struct sockaddr_in *addr4 = NULL; struct sockaddr_in6 *addr6 = NULL; unsigned short snum; u32 sid, perm; if (sk->sk_family == PF_INET) { addr4 = (struct sockaddr_in *)address; if (addrlen < sizeof(struct sockaddr_in)) return -EINVAL; snum = ntohs(addr4->sin_port); } else { addr6 = (struct sockaddr_in6 *)address; if (addrlen < SIN6_LEN_RFC2133) return -EINVAL; snum = ntohs(addr6->sin6_port); } err = sel_netport_sid(sk->sk_protocol, snum, &sid); if (err) goto out; perm = (sksec->sclass == SECCLASS_TCP_SOCKET) ? TCP_SOCKET__NAME_CONNECT : DCCP_SOCKET__NAME_CONNECT; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->dport = htons(snum); ad.u.net->family = sk->sk_family; err = avc_has_perm(sksec->sid, sid, sksec->sclass, perm, &ad); if (err) goto out; } err = selinux_netlbl_socket_connect(sk, address); out: return err; }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley19464.88%216.67%
paul moorepaul moore3210.70%325.00%
andrew mortonandrew morton268.70%18.33%
eric pariseric paris248.03%433.33%
james morrisjames morris227.36%18.33%
thomas liuthomas liu10.33%18.33%
Total299100.00%12100.00%


static int selinux_socket_listen(struct socket *sock, int backlog) { return sock_has_perm(current, sock->sk, SOCKET__LISTEN); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2388.46%266.67%
paul moorepaul moore311.54%133.33%
Total26100.00%3100.00%


static int selinux_socket_accept(struct socket *sock, struct socket *newsock) { int err; struct inode_security_struct *isec; struct inode_security_struct *newisec; err = sock_has_perm(current, sock->sk, SOCKET__ACCEPT); if (err) return err; newisec = inode_security_novalidate(SOCK_INODE(newsock)); isec = inode_security_novalidate(SOCK_INODE(sock)); newisec->sclass = isec->sclass; newisec->sid = isec->sid; newisec->initialized = LABEL_INITIALIZED; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton7984.04%228.57%
andreas gruenbacherandreas gruenbacher77.45%342.86%
stephen d. smalleystephen d. smalley55.32%114.29%
paul moorepaul moore33.19%114.29%
Total94100.00%7100.00%


static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size) { return sock_has_perm(current, sock->sk, SOCKET__WRITE); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2787.10%250.00%
paul moorepaul moore412.90%250.00%
Total31100.00%4100.00%


static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg, int size, int flags) { return sock_has_perm(current, sock->sk, SOCKET__READ); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3191.18%266.67%
paul moorepaul moore38.82%133.33%
Total34100.00%3100.00%


static int selinux_socket_getsockname(struct socket *sock) { return sock_has_perm(current, sock->sk, SOCKET__GETATTR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2086.96%266.67%
paul moorepaul moore313.04%133.33%
Total23100.00%3100.00%


static int selinux_socket_getpeername(struct socket *sock) { return sock_has_perm(current, sock->sk, SOCKET__GETATTR); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2086.96%266.67%
paul moorepaul moore313.04%133.33%
Total23100.00%3100.00%


static int selinux_socket_setsockopt(struct socket *sock, int level, int optname) { int err; err = sock_has_perm(current, sock->sk, SOCKET__SETOPT); if (err) return err; return selinux_netlbl_socket_setsockopt(sock, level, optname); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2550.00%133.33%
paul moorepaul moore2550.00%266.67%
Total50100.00%3100.00%


static int selinux_socket_getsockopt(struct socket *sock, int level, int optname) { return sock_has_perm(current, sock->sk, SOCKET__GETOPT); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2689.66%150.00%
paul moorepaul moore310.34%150.00%
Total29100.00%2100.00%


static int selinux_socket_shutdown(struct socket *sock, int how) { return sock_has_perm(current, sock->sk, SOCKET__SHUTDOWN); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2388.46%150.00%
paul moorepaul moore311.54%150.00%
Total26100.00%2100.00%


static int selinux_socket_unix_stream_connect(struct sock *sock, struct sock *other, struct sock *newsk) { struct sk_security_struct *sksec_sock = sock->sk_security; struct sk_security_struct *sksec_other = other->sk_security; struct sk_security_struct *sksec_new = newsk->sk_security; struct common_audit_data ad; struct lsm_network_audit net = {0,}; int err; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->sk = other; err = avc_has_perm(sksec_sock->sid, sksec_other->sid, sksec_other->sclass, UNIX_STREAM_SOCKET__CONNECTTO, &ad); if (err) return err; /* server child socket */ sksec_new->peer_sid = sksec_sock->sid; err = security_sid_mls_copy(sksec_other->sid, sksec_sock->sid, &sksec_new->sid); if (err) return err; /* connecting socket */ sksec_sock->peer_sid = sksec_new->sid; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton8049.08%220.00%
paul moorepaul moore4225.77%110.00%
eric pariseric paris2314.11%440.00%
venkat yekkiralavenkat yekkirala159.20%110.00%
david s. millerdavid s. miller21.23%110.00%
thomas liuthomas liu10.61%110.00%
Total163100.00%10100.00%


static int selinux_socket_unix_may_send(struct socket *sock, struct socket *other) { struct sk_security_struct *ssec = sock->sk->sk_security; struct sk_security_struct *osec = other->sk->sk_security; struct common_audit_data ad; struct lsm_network_audit net = {0,}; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->sk = other->sk; return avc_has_perm(ssec->sid, osec->sid, osec->sclass, SOCKET__SENDTO, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5455.10%114.29%
eric pariseric paris2323.47%457.14%
paul moorepaul moore2020.41%114.29%
thomas liuthomas liu11.02%114.29%
Total98100.00%7100.00%


static int selinux_inet_sys_rcv_skb(struct net *ns, int ifindex, char *addrp, u16 family, u32 peer_sid, struct common_audit_data *ad) { int err; u32 if_sid; u32 node_sid; err = sel_netif_sid(ns, ifindex, &if_sid); if (err) return err; err = avc_has_perm(peer_sid, if_sid, SECCLASS_NETIF, NETIF__INGRESS, ad); if (err) return err; err = sel_netnode_sid(addrp, family, &node_sid); if (err) return err; return avc_has_perm(peer_sid, node_sid, SECCLASS_NODE, NODE__RECVFROM, ad); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore11199.11%266.67%
thomas liuthomas liu10.89%133.33%
Total112100.00%3100.00%


static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb, u16 family) { int err = 0; struct sk_security_struct *sksec = sk->sk_security; u32 sk_sid = sksec->sid; struct common_audit_data ad; struct lsm_network_audit net = {0,}; char *addrp; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->netif = skb->skb_iif; ad.u.net->family = family; err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL); if (err) return err; if (selinux_secmark_enabled()) { err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET, PACKET__RECV, &ad); if (err) return err; } err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad); if (err) return err; err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad); return err; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore10053.48%213.33%
andrew mortonandrew morton5328.34%533.33%
eric pariseric paris2412.83%426.67%
james morrisjames morris42.14%16.67%
venkat yekkiralavenkat yekkirala42.14%16.67%
thomas liuthomas liu10.53%16.67%
eric dumazeteric dumazet10.53%16.67%
Total187100.00%15100.00%


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 (family != PF_INET && family != PF_INET6) return 0; /* Handle mapped IPv4 packets arriving via IPv6 sockets */ if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP)) family = PF_INET; /* If any sort of compatibility mode is enabled then handoff processing * to the selinux_sock_rcv_skb_compat() function to deal with the * special handling. We do this in an attempt to keep this function * as fast and as clean as possible. */ if (!selinux_policycap_netpeer) return selinux_sock_rcv_skb_compat(sk, skb, family); secmark_active = selinux_secmark_enabled(); peerlbl_active = selinux_peerlbl_enabled(); if (!secmark_active && !peerlbl_active) return 0; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->netif = skb->skb_iif; ad.u.net->family = family; err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL); if (err) return err; if (peerlbl_active) { u32 peer_sid; err = selinux_skb_peerlbl_sid(skb, family, &peer_sid); if (err) return err; err = selinux_inet_sys_rcv_skb(sock_net(sk), skb->skb_iif, addrp, family, peer_sid, &ad); if (err) { selinux_netlbl_err(skb, err, 0); return err; } err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER, PEER__RECV, &ad); if (err) { selinux_netlbl_err(skb, err, 0); return err; } } if (secmark_active) { err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET, PACKET__RECV, &ad); if (err) return err; } return err; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore17953.92%834.78%
james morrisjames morris7522.59%14.35%
andrew mortonandrew morton278.13%14.35%
eric pariseric paris247.23%417.39%
venkat yekkiralavenkat yekkirala154.52%313.04%
chad hansonchad hanson51.51%14.35%
catherine zhangcatherine zhang20.60%14.35%
eric dumazeteric dumazet20.60%14.35%
thomas liuthomas liu10.30%14.35%
al viroal viro10.30%14.35%
christopher j. pebenitochristopher j. pebenito10.30%14.35%
Total332100.00%23100.00%


static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *optval, int __user *optlen, unsigned len) { int err = 0; char *scontext; u32 scontext_len; struct sk_security_struct *sksec = sock->sk->sk_security; u32 peer_sid = SECSID_NULL; if (sksec->sclass == SECCLASS_UNIX_STREAM_SOCKET || sksec->sclass == SECCLASS_TCP_SOCKET) peer_sid = sksec->peer_sid; if (peer_sid == SECSID_NULL) return -ENOPROTOOPT; err = security_sid_to_context(peer_sid, &scontext, &scontext_len); if (err) return err; if (scontext_len > len) { err = -ERANGE; goto out_len; } if (copy_to_user(optval, scontext, scontext_len)) err = -EFAULT; out_len: if (put_user(scontext_len, optlen)) err = -EFAULT; kfree(scontext); return err; }

Contributors

PersonTokensPropCommitsCommitProp
james morrisjames morris10767.72%116.67%
andrew mortonandrew morton3018.99%116.67%
paul moorepaul moore159.49%233.33%
venkat yekkiralavenkat yekkirala42.53%116.67%
eric pariseric paris21.27%116.67%
Total158100.00%6100.00%


static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid) { u32 peer_secid = SECSID_NULL; u16 family; struct inode_security_struct *isec; if (skb && skb->protocol == htons(ETH_P_IP)) family = PF_INET; else if (skb && skb->protocol == htons(ETH_P_IPV6)) family = PF_INET6; else if (sock) family = sock->sk->sk_family; else goto out; if (sock && family == PF_UNIX) { isec = inode_security_novalidate(SOCK_INODE(sock)); peer_secid = isec->sid; } else if (skb) selinux_skb_peerlbl_sid(skb, family, &peer_secid); out: *secid = peer_secid; if (peer_secid == SECSID_NULL) return -EINVAL; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore8860.27%555.56%
catherine zhangcatherine zhang5638.36%333.33%
venkat yekkiralavenkat yekkirala21.37%111.11%
Total146100.00%9100.00%


static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority) { struct sk_security_struct *sksec; sksec = kzalloc(sizeof(*sksec), priority); if (!sksec) return -ENOMEM; sksec->peer_sid = SECINITSID_UNLABELED; sksec->sid = SECINITSID_UNLABELED; sksec->sclass = SECCLASS_SOCKET; selinux_netlbl_sk_security_reset(sksec); sk->sk_security = sksec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore4863.16%125.00%
andrew mortonandrew morton2127.63%125.00%
stephen d. smalleystephen d. smalley67.89%125.00%
al viroal viro11.32%125.00%
Total76100.00%4100.00%


static void selinux_sk_free_security(struct sock *sk) { struct sk_security_struct *sksec = sk->sk_security; sk->sk_security = NULL; selinux_netlbl_sk_security_free(sksec); kfree(sksec); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore2261.11%150.00%
andrew mortonandrew morton1438.89%150.00%
Total36100.00%2100.00%


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; newsksec->sid = sksec->sid; newsksec->peer_sid = sksec->peer_sid; newsksec->sclass = sksec->sclass; selinux_netlbl_sk_security_reset(newsksec); }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala4570.31%120.00%
paul moorepaul moore1015.62%360.00%
eric pariseric paris914.06%120.00%
Total64100.00%5100.00%


static void selinux_sk_getsecid(struct sock *sk, u32 *secid) { if (!sk) *secid = SECINITSID_ANY_SOCKET; else { struct sk_security_struct *sksec = sk->sk_security; *secid = sksec->sid; } }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala44100.00%1100.00%
Total44100.00%1100.00%


static void selinux_sock_graft(struct sock *sk, struct socket *parent) { struct inode_security_struct *isec = inode_security_novalidate(SOCK_INODE(parent)); struct sk_security_struct *sksec = sk->sk_security; if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 || sk->sk_family == PF_UNIX) isec->sid = sksec->sid; sksec->sclass = isec->sclass; }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala4256.76%114.29%
paul moorepaul moore2128.38%228.57%
david woodhousedavid woodhouse79.46%114.29%
andreas gruenbacherandreas gruenbacher34.05%228.57%
adrian bunkadrian bunk11.35%114.29%
Total74100.00%7100.00%


static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb, struct request_sock *req) { struct sk_security_struct *sksec = sk->sk_security; int err; u16 family = req->rsk_ops->family; u32 connsid; u32 peersid; err = selinux_skb_peerlbl_sid(skb, family, &peersid); if (err) return err; err = selinux_conn_sid(sksec->sid, peersid, &connsid); if (err) return err; req->secid = connsid; req->peer_secid = peersid; return selinux_netlbl_inet_conn_request(req, family); }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala7872.22%541.67%
paul moorepaul moore2926.85%650.00%
adrian bunkadrian bunk10.93%18.33%
Total108100.00%12100.00%


static void selinux_inet_csk_clone(struct sock *newsk, const struct request_sock *req) { struct sk_security_struct *newsksec = newsk->sk_security; newsksec->sid = req->secid; newsksec->peer_sid = req->peer_secid; /* NOTE: Ideally, we should also get the isec->sid for the new socket in sync, but we don't have the isec available yet. So we will wait until sock_graft to do it, by which time it will have been created and available. */ /* We don't need to take any sort of lock here as we are the only * thread with access to newsksec */ selinux_netlbl_inet_csk_clone(newsk, req->rsk_ops->family); }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala3054.55%444.44%
trent jaegertrent jaeger1221.82%111.11%
paul moorepaul moore1221.82%333.33%
adrian bunkadrian bunk11.82%111.11%
Total55100.00%9100.00%


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; /* handle mapped IPv4 packets arriving via IPv6 sockets */ if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP)) family = PF_INET; selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid); }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala3453.12%125.00%
paul moorepaul moore3046.88%375.00%
Total64100.00%4100.00%


static int selinux_secmark_relabel_packet(u32 sid) { const struct task_security_struct *__tsec; u32 tsid; __tsec = current_security(); tsid = __tsec->sid; return avc_has_perm(tsid, sid, SECCLASS_PACKET, PACKET__RELABELTO, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris43100.00%1100.00%
Total43100.00%1100.00%


static void selinux_secmark_refcount_inc(void) { atomic_inc(&selinux_secmark_refcount); }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris14100.00%1100.00%
Total14100.00%1100.00%


static void selinux_secmark_refcount_dec(void) { atomic_dec(&selinux_secmark_refcount); }

Contributors

PersonTokensPropCommitsCommitProp
eric pariseric paris14100.00%1100.00%
Total14100.00%1100.00%


static void selinux_req_classify_flow(const struct request_sock *req, struct flowi *fl) { fl->flowi_secid = req->secid; }

Contributors

PersonTokensPropCommitsCommitProp
venkat yekkiralavenkat yekkirala2392.00%250.00%
david s. millerdavid s. miller14.00%125.00%
adrian bunkadrian bunk14.00%125.00%
Total25100.00%4100.00%


static int selinux_tun_dev_alloc_security(void **security) { struct tun_security_struct *tunsec; tunsec = kzalloc(sizeof(*tunsec), GFP_KERNEL); if (!tunsec) return -ENOMEM; tunsec->sid = current_sid(); *security = tunsec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore53100.00%1100.00%
Total53100.00%1100.00%


static void selinux_tun_dev_free_security(void *security) { kfree(security); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore15100.00%1100.00%
Total15100.00%1100.00%


static int selinux_tun_dev_create(void) { u32 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, * instead it is a private sock, accessible only to the kernel, and * representing a wide range of network traffic spanning multiple * connections unlike traditional sockets - check the TUN driver to * get a better understanding of why this socket is special */ return avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__CREATE, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore29100.00%1100.00%
Total29100.00%1100.00%


static int selinux_tun_dev_attach_queue(void *security) { struct tun_security_struct *tunsec = security; return avc_has_perm(current_sid(), tunsec->sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__ATTACH_QUEUE, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore34100.00%2100.00%
Total34100.00%2100.00%


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; /* 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 * traffic from the other end of the connection would almost certainly * cause confusion to the TUN user that had no idea network labeling * protocols were being used */ sksec->sid = tunsec->sid; sksec->sclass = SECCLASS_TUN_SOCKET; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore49100.00%2100.00%
Total49100.00%2100.00%


static int selinux_tun_dev_open(void *security) { struct tun_security_struct *tunsec = security; u32 sid = current_sid(); int err; err = avc_has_perm(sid, tunsec->sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__RELABELFROM, NULL); if (err) return err; err = avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__RELABELTO, NULL); if (err) return err; tunsec->sid = sid; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore81100.00%2100.00%
Total81100.00%2100.00%


static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb) { int err = 0; u32 perm; struct nlmsghdr *nlh; struct sk_security_struct *sksec = sk->sk_security; if (skb->len < NLMSG_HDRLEN) { err = -EINVAL; goto out; } nlh = nlmsg_hdr(skb); err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm); if (err) { if (err == -EINVAL) { pr_warn_ratelimited("SELinux: unrecognized netlink" " message: protocol=%hu nlmsg_type=%hu sclass=%s" " pig=%d comm=%s\n", sk->sk_protocol, nlh->nlmsg_type, secclass_map[sksec->sclass - 1].name, task_pid_nr(current), current->comm); if (!selinux_enforcing || security_get_allow_unknown()) err = 0; } /* Ignore */ if (err == -ENOENT) err = 0; goto out; } err = sock_has_perm(current, sk, perm); out: return err; }

Contributors

PersonTokensPropCommitsCommitProp
james morrisjames morris10661.63%218.18%
stephen d. smalleystephen d. smalley2816.28%19.09%
vladis dronovvladis dronov137.56%19.09%
marek milkovicmarek milkovic74.07%19.09%
paul moorepaul moore74.07%19.09%
arnaldo carvalho de meloarnaldo carvalho de melo31.74%19.09%
richard guy briggsrichard guy briggs31.74%19.09%
eric pariseric paris31.74%19.09%
hong zhi guohong zhi guo10.58%19.09%
steve grubbsteve grubb10.58%19.09%
Total172100.00%11100.00%

#ifdef CONFIG_NETFILTER
static unsigned int selinux_ip_forward(struct sk_buff *skb, const struct net_device *indev, u16 family) { int err; char *addrp; u32 peer_sid; struct common_audit_data ad; struct lsm_network_audit net = {0,}; u8 secmark_active; u8 netlbl_active; u8 peerlbl_active; if (!selinux_policycap_netpeer) return NF_ACCEPT; secmark_active = selinux_secmark_enabled(); netlbl_active = netlbl_enabled(); peerlbl_active = selinux_peerlbl_enabled(); if (!secmark_active && !peerlbl_active) return NF_ACCEPT; if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0) return NF_DROP; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->netif = indev->ifindex; ad.u.net->family = family; if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0) return NF_DROP; if (peerlbl_active) { err = selinux_inet_sys_rcv_skb(dev_net(indev), indev->ifindex, addrp, family, peer_sid, &ad); if (err) { selinux_netlbl_err(skb, err, 1); return NF_DROP; } } if (secmark_active) if (avc_has_perm(peer_sid, skb->secmark, SECCLASS_PACKET, PACKET__FORWARD_IN, &ad)) return NF_DROP; if (netlbl_active) /* we do this in the FORWARD path and not the POST_ROUTING * path because we want to make sure we apply the necessary * labeling before IPsec is applied so we can leverage AH * protection */ if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0) return NF_DROP; return NF_ACCEPT; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore20780.23%538.46%
eric pariseric paris249.30%430.77%
james morrisjames morris155.81%17.69%
venkat yekkiralavenkat yekkirala103.88%17.69%
christopher j. pebenitochristopher j. pebenito10.39%17.69%
thomas liuthomas liu10.39%17.69%
Total258100.00%13100.00%


static unsigned int selinux_ipv4_forward(void *priv, struct sk_buff *skb, const struct nf_hook_state *state) { return selinux_ip_forward(skb, state->in, PF_INET); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore2779.41%125.00%
david s. millerdavid s. miller411.76%125.00%
eric w. biedermaneric w. biederman25.88%125.00%
patrick mchardypatrick mchardy12.94%125.00%
Total34100.00%4100.00%

#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
static unsigned int selinux_ipv6_forward(void *priv, struct sk_buff *skb, const struct nf_hook_state *state) { return selinux_ip_forward(skb, state->in, PF_INET6); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore2779.41%125.00%
david s. millerdavid s. miller411.76%125.00%
eric w. biedermaneric w. biederman25.88%125.00%
patrick mchardypatrick mchardy12.94%125.00%
Total34100.00%4100.00%

#endif /* IPV6 */
static unsigned int selinux_ip_output(struct sk_buff *skb, u16 family) { struct sock *sk; u32 sid; if (!netlbl_enabled()) return NF_ACCEPT; /* we do this in the LOCAL_OUT path and not the POST_ROUTING path * because we want to make sure we apply the necessary labeling * before IPsec is applied so we can leverage AH protection */ sk = skb->sk; if (sk) { struct sk_security_struct *sksec; if (sk_listener(sk)) /* if the socket is the listening state then this * packet is a SYN-ACK packet which means it needs to * be labeled based on the connection/request_sock and * not the parent socket. unfortunately, we can't * lookup the request_sock yet as it isn't queued on * the parent socket until after the SYN-ACK is sent. * the "solution" is to simply pass the packet as-is * as any IP option based labeling should be copied * from the initial connection request (in the IP * layer). it is far from ideal, but until we get a * security label in the packet itself this is the * best we can do. */ return NF_ACCEPT; /* standard practice, label using the parent socket */ sksec = sk->sk_security; sid = sksec->sid; } else sid = SECINITSID_KERNEL; if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0) return NF_DROP; return NF_ACCEPT; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore9596.94%266.67%
eric dumazeteric dumazet33.06%133.33%
Total98100.00%3100.00%


static unsigned int selinux_ipv4_output(void *priv, struct sk_buff *skb, const struct nf_hook_state *state) { return selinux_ip_output(skb, PF_INET); }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore2583.33%125.00%
eric w. biedermaneric w. biederman26.67%125.00%
david s. millerdavid s. miller26.67%125.00%
patrick mchardypatrick mchardy13.33%125.00%
Total30100.00%4100.00%


static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb, int ifindex, u16 family) { struct sock *sk = skb_to_full_sk(skb); struct sk_security_struct *sksec; struct common_audit_data ad; struct lsm_network_audit net = {0,}; char *addrp; u8 proto; if (sk == NULL) return NF_ACCEPT; sksec = sk->sk_security; ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->netif = ifindex; ad.u.net->family = family; if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto)) return NF_DROP; if (selinux_secmark_enabled()) if (avc_has_perm(sksec->sid, skb->secmark, SECCLASS_PACKET, PACKET__SEND, &ad)) return NF_DROP_ERR(-ECONNREFUSED); if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto)) return NF_DROP_ERR(-ECONNREFUSED); return NF_ACCEPT; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore13071.82%428.57%
eric pariseric paris3418.78%535.71%
james morrisjames morris137.18%214.29%
eric dumazeteric dumazet31.66%214.29%
thomas liuthomas liu10.55%17.14%
Total181100.00%14100.00%


static unsigned int selinux_ip_postroute(struct sk_buff *skb, const struct net_device *outdev, u16 family) { u32 secmark_perm; u32 peer_sid; int ifindex = outdev->ifindex; struct sock *sk; struct common_audit_data ad; struct lsm_network_audit net = {0,}; char *addrp; u8 secmark_active; u8 peerlbl_active; /* If any sort of compatibility mode is enabled then handoff processing * to the selinux_ip_postroute_compat() function to deal with the * special handling. We do this in an attempt to keep this function * as fast and as clean as possible. */ if (!selinux_policycap_netpeer) return selinux_ip_postroute_compat(skb, ifindex, family); secmark_active = selinux_secmark_enabled(); peerlbl_active = selinux_peerlbl_enabled(); if (!secmark_active && !peerlbl_active) return NF_ACCEPT; sk = skb_to_full_sk(skb); #ifdef CONFIG_XFRM /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec * packet transformation so allow the packet to pass without any checks * since we'll have another chance to perform access control checks * when the packet is on it's final way out. * NOTE: there appear to be some IPv6 multicast cases where skb->dst * is NULL, in this case go ahead and apply access control. * NOTE: if this is a local socket (skb->sk != NULL) that is in the * TCP listening state we cannot wait until the XFRM processing * is done as we will miss out on the SA label if we do; * unfortunately, this means more work, but it is only once per * connection. */ if (skb_dst(skb) != NULL && skb_dst(skb)->xfrm != NULL && !(sk && sk_listener(sk))) return NF_ACCEPT; #endif if (sk == NULL) { /* Without an associated socket the packet is either coming * from the kernel or it is being forwarded; check the packet * to determine which and if the packet is being forwarded * query the packet directly to determine the security label. */ if (skb->skb_iif) { secmark_perm = PACKET__FORWARD_OUT; if (selinux_skb_peerlbl_sid(skb, family, &peer_sid)) return NF_DROP; } else { secmark_perm = PACKET__SEND; peer_sid = SECINITSID_KERNEL; } } else if (sk_listener(sk)) { /* Locally generated packet but the associated socket is in the * listening state which means this is a SYN-ACK packet. In * this particular case the correct security label is assigned * to the connection/request_sock but unfortunately we can't * query the request_sock as it isn't queued on the parent * socket until after the SYN-ACK packet is sent; the only * viable choice is to regenerate the label like we do in * selinux_inet_conn_request(). See also selinux_ip_output() * for similar problems. */ u32 skb_sid; struct sk_security_struct *sksec; sksec = sk->sk_security; if (selinux_skb_peerlbl_sid(skb, family, &skb_sid)) return NF_DROP; /* At this point, if the returned skb peerlbl is SECSID_NULL * and the packet has been through at least one XFRM * transformation then we must be dealing with the "final" * form of labeled IPsec packet; since we've already applied * all of our access controls on this packet we can safely * pass the packet. */ if (skb_sid == SECSID_NULL) { switch (family) { case PF_INET: if (IPCB(skb)->flags & IPSKB_XFRM_TRANSFORMED) return NF_ACCEPT; break; case PF_INET6: if (IP6CB(skb)->flags & IP6SKB_XFRM_TRANSFORMED) return NF_ACCEPT; break; default: return NF_DROP_ERR(-ECONNREFUSED); } } if (selinux_conn_sid(sksec->sid, skb_sid, &peer_sid)) return NF_DROP; secmark_perm = PACKET__SEND; } else { /* Locally generated packet, fetch the security label from the * associated socket. */ struct sk_security_struct *sksec = sk->sk_security; peer_sid = sksec->sid; secmark_perm = PACKET__SEND; } ad.type = LSM_AUDIT_DATA_NET; ad.u.net = &net; ad.u.net->netif = ifindex; ad.u.net->family = family; if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL)) return NF_DROP; if (secmark_active) if (avc_has_perm(peer_sid, skb->secmark, SECCLASS_PACKET, secmark_perm, &ad)) return NF_DROP_ERR(-ECONNREFUSED); if (peerlbl_active) { u32 if_sid; u32 node_sid; if (sel_netif_sid(dev_net(outdev), ifindex, &if_sid)) return NF_DROP; if (avc_has_perm(peer_sid, if_sid, SECCLASS_NETIF, NETIF__EGRESS, &ad)) return NF_DROP_ERR(-ECONNREFUSED); if (sel_netnode_sid(addrp, family, &node_sid)) return NF_DROP; if (avc_has_perm(peer_sid, node_sid, SECCLASS_NODE, NODE__SENDTO, &ad)) return NF_DROP_ERR(-ECONNREFUSED); } return NF_ACCEPT; }

Contributors

PersonTokensPropCommitsCommitProp
paul moorepaul moore37974.31%620.00%
andrew mortonandrew morton489.41%620.00%
eric pariseric paris438.43%620.00%
eric dumazeteric dumazet132.55%310.00%
steffen klassertsteffen klassert81.57%13.33%
venkat yekkiralavenkat yekkirala81.57%310.00%
trent jaegertrent jaeger61.18%13.33%
james morrisjames morris20.39%13.33%
david s. millerdavid s. miller10.20%13.33%
christopher j. pebenitochristopher j. pebenito10.20%13.33%
thomas liuthomas liu10.20%13.33%
Total510100.00%30100.00%


static unsigned int selinux_ipv4_postroute(void *priv, struct sk_buff *skb, const struct nf_hook_state *state) { return selinux_ip_postroute(skb, state->out, PF_INET); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2367.65%116.67%
david s. millerdavid s. miller617.65%233.33%
eric w. biedermaneric w. biederman25.88%116.67%
paul moorepaul moore25.88%116.67%
patrick mchardypatrick mchardy12.94%116.67%
Total34100.00%6100.00%

#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
static unsigned int selinux_ipv6_postroute(void *priv, struct sk_buff *skb, const struct nf_hook_state *state) { return selinux_ip_postroute(skb, state->out, PF_INET6); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2367.65%116.67%
david s. millerdavid s. miller617.65%233.33%
paul moorepaul moore25.88%116.67%
eric w. biedermaneric w. biederman25.88%116.67%
patrick mchardypatrick mchardy12.94%116.67%
Total34100.00%6100.00%

#endif /* IPV6 */ #endif /* CONFIG_NETFILTER */
static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb) { return selinux_nlmsg_perm(sk, skb); }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley24100.00%2100.00%
Total24100.00%2100.00%


static int ipc_alloc_security(struct task_struct *task, struct kern_ipc_perm *perm, u16 sclass) { struct ipc_security_struct *isec; u32 sid; isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL); if (!isec) return -ENOMEM; sid = task_sid(task); isec->sclass = sclass; isec->sid = sid; perm->security = isec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton6685.71%133.33%
david howellsdavid howells1012.99%133.33%
james morrisjames morris11.30%133.33%
Total77100.00%3100.00%


static void ipc_free_security(struct kern_ipc_perm *perm) { struct ipc_security_struct *isec = perm->security; perm->security = NULL; kfree(isec); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton31100.00%2100.00%
Total31100.00%2100.00%


static int msg_msg_alloc_security(struct msg_msg *msg) { struct msg_security_struct *msec; msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL); if (!msec) return -ENOMEM; msec->sid = SECINITSID_UNLABELED; msg->security = msec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5298.11%150.00%
james morrisjames morris11.89%150.00%
Total53100.00%2100.00%


static void msg_msg_free_security(struct msg_msg *msg) { struct msg_security_struct *msec = msg->security; msg->security = NULL; kfree(msec); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton31100.00%1100.00%
Total31100.00%1100.00%


static int ipc_has_perm(struct kern_ipc_perm *ipc_perms, u32 perms) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); isec = ipc_perms->security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = ipc_perms->key; return avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5578.57%114.29%
eric pariseric paris68.57%342.86%
david howellsdavid howells68.57%114.29%
stephen d. smalleystephen d. smalley22.86%114.29%
thomas liuthomas liu11.43%114.29%
Total70100.00%7100.00%


static int selinux_msg_msg_alloc_security(struct msg_msg *msg) { return msg_msg_alloc_security(msg); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton17100.00%1100.00%
Total17100.00%1100.00%


static void selinux_msg_msg_free_security(struct msg_msg *msg) { msg_msg_free_security(msg); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton16100.00%2100.00%
Total16100.00%2100.00%

/* message queue security operations */
static int selinux_msg_queue_alloc_security(struct msg_queue *msq) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); int rc; rc = ipc_alloc_security(current, &msq->q_perm, SECCLASS_MSGQ); if (rc) return rc; isec = msq->q_perm.security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = msq->q_perm.key; rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ, MSGQ__CREATE, &ad); if (rc) { ipc_free_security(&msq->q_perm); return rc; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton10188.60%116.67%
david howellsdavid howells65.26%116.67%
eric pariseric paris65.26%350.00%
thomas liuthomas liu10.88%116.67%
Total114100.00%6100.00%


static void selinux_msg_queue_free_security(struct msg_queue *msq) { ipc_free_security(&msq->q_perm); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton19100.00%1100.00%
Total19100.00%1100.00%


static int selinux_msg_queue_associate(struct msg_queue *msq, int msqflg) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); isec = msq->q_perm.security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = msq->q_perm.key; return avc_has_perm(sid, isec->sid, SECCLASS_MSGQ, MSGQ__ASSOCIATE, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5981.94%116.67%
eric pariseric paris68.33%350.00%
david howellsdavid howells68.33%116.67%
thomas liuthomas liu11.39%116.67%
Total72100.00%6100.00%


static int selinux_msg_queue_msgctl(struct msg_queue *msq, int cmd) { int err; int perms; switch (cmd) { case IPC_INFO: case MSG_INFO: /* No specific object, just general system-wide information. */ return task_has_system(current, SYSTEM__IPC_INFO); case IPC_STAT: case MSG_STAT: perms = MSGQ__GETATTR | MSGQ__ASSOCIATE; break; case IPC_SET: perms = MSGQ__SETATTR; break; case IPC_RMID: perms = MSGQ__DESTROY; break; default: return 0; } err = ipc_has_perm(&msq->q_perm, perms); return err; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton89100.00%1100.00%
Total89100.00%1100.00%


static int selinux_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, int msqflg) { struct ipc_security_struct *isec; struct msg_security_struct *msec; struct common_audit_data ad; u32 sid = current_sid(); int rc; isec = msq->q_perm.security; msec = msg->security; /* * First time through, need to assign label to the message */ if (msec->sid == SECINITSID_UNLABELED) { /* * Compute new sid based on current process and * message queue this message will be stored in */ rc = security_transition_sid(sid, isec->sid, SECCLASS_MSG, NULL, &msec->sid); if (rc) return rc; } ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = msq->q_perm.key; /* Can this process write to the queue? */ rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ, MSGQ__WRITE, &ad); if (!rc) /* Can this process send the message */ rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG, MSG__SEND, &ad); if (!rc) /* Can the message be put in the queue? */ rc = avc_has_perm(msec->sid, isec->sid, SECCLASS_MSGQ, MSGQ__ENQUEUE, &ad); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton17091.89%114.29%
eric pariseric paris84.32%457.14%
david howellsdavid howells63.24%114.29%
thomas liuthomas liu10.54%114.29%
Total185100.00%7100.00%


static int selinux_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg, struct task_struct *target, long type, int mode) { struct ipc_security_struct *isec; struct msg_security_struct *msec; struct common_audit_data ad; u32 sid = task_sid(target); int rc; isec = msq->q_perm.security; msec = msg->security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = msq->q_perm.key; rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ, MSGQ__READ, &ad); if (!rc) rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG, MSG__RECEIVE, &ad); return rc; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton11388.28%116.67%
david howellsdavid howells86.25%116.67%
eric pariseric paris64.69%350.00%
thomas liuthomas liu10.78%116.67%
Total128100.00%6100.00%

/* Shared Memory security operations */
static int selinux_shm_alloc_security(struct shmid_kernel *shp) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); int rc; rc = ipc_alloc_security(current, &shp->shm_perm, SECCLASS_SHM); if (rc) return rc; isec = shp->shm_perm.security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = shp->shm_perm.key; rc = avc_has_perm(sid, isec->sid, SECCLASS_SHM, SHM__CREATE, &ad); if (rc) { ipc_free_security(&shp->shm_perm); return rc; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton10188.60%116.67%
eric pariseric paris65.26%350.00%
david howellsdavid howells65.26%116.67%
thomas liuthomas liu10.88%116.67%
Total114100.00%6100.00%


static void selinux_shm_free_security(struct shmid_kernel *shp) { ipc_free_security(&shp->shm_perm); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton19100.00%1100.00%
Total19100.00%1100.00%


static int selinux_shm_associate(struct shmid_kernel *shp, int shmflg) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); isec = shp->shm_perm.security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = shp->shm_perm.key; return avc_has_perm(sid, isec->sid, SECCLASS_SHM, SHM__ASSOCIATE, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5981.94%116.67%
david howellsdavid howells68.33%116.67%
eric pariseric paris68.33%350.00%
thomas liuthomas liu11.39%116.67%
Total72100.00%6100.00%

/* Note, at this point, shp is locked down */
static int selinux_shm_shmctl(struct shmid_kernel *shp, int cmd) { int perms; int err; switch (cmd) { case IPC_INFO: case SHM_INFO: /* No specific object, just general system-wide information. */ return task_has_system(current, SYSTEM__IPC_INFO); case IPC_STAT: case SHM_STAT: perms = SHM__GETATTR | SHM__ASSOCIATE; break; case IPC_SET: perms = SHM__SETATTR; break; case SHM_LOCK: case SHM_UNLOCK: perms = SHM__LOCK; break; case IPC_RMID: perms = SHM__DESTROY; break; default: return 0; } err = ipc_has_perm(&shp->shm_perm, perms); return err; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton100100.00%1100.00%
Total100100.00%1100.00%


static int selinux_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr, int shmflg) { u32 perms; if (shmflg & SHM_RDONLY) perms = SHM__READ; else perms = SHM__READ | SHM__WRITE; return ipc_has_perm(&shp->shm_perm, perms); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton4998.00%150.00%
chris wrightchris wright12.00%150.00%
Total50100.00%2100.00%

/* Semaphore security operations */
static int selinux_sem_alloc_security(struct sem_array *sma) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); int rc; rc = ipc_alloc_security(current, &sma->sem_perm, SECCLASS_SEM); if (rc) return rc; isec = sma->sem_perm.security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = sma->sem_perm.key; rc = avc_has_perm(sid, isec->sid, SECCLASS_SEM, SEM__CREATE, &ad); if (rc) { ipc_free_security(&sma->sem_perm); return rc; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton10188.60%116.67%
david howellsdavid howells65.26%116.67%
eric pariseric paris65.26%350.00%
thomas liuthomas liu10.88%116.67%
Total114100.00%6100.00%


static void selinux_sem_free_security(struct sem_array *sma) { ipc_free_security(&sma->sem_perm); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton19100.00%1100.00%
Total19100.00%1100.00%


static int selinux_sem_associate(struct sem_array *sma, int semflg) { struct ipc_security_struct *isec; struct common_audit_data ad; u32 sid = current_sid(); isec = sma->sem_perm.security; ad.type = LSM_AUDIT_DATA_IPC; ad.u.ipc_id = sma->sem_perm.key; return avc_has_perm(sid, isec->sid, SECCLASS_SEM, SEM__ASSOCIATE, &ad); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5981.94%116.67%
eric pariseric paris68.33%350.00%
david howellsdavid howells68.33%116.67%
thomas liuthomas liu11.39%116.67%
Total72100.00%6100.00%

/* Note, at this point, sma is locked down */
static int selinux_sem_semctl(struct sem_array *sma, int cmd) { int err; u32 perms; switch (cmd) { case IPC_INFO: case SEM_INFO: /* No specific object, just general system-wide information. */ return task_has_system(current, SYSTEM__IPC_INFO); case GETPID: case GETNCNT: case GETZCNT: perms = SEM__GETATTR; break; case GETVAL: case GETALL: perms = SEM__READ; break; case SETVAL: case SETALL: perms = SEM__WRITE; break; case IPC_RMID: perms = SEM__DESTROY; break; case IPC_SET: perms = SEM__SETATTR; break; case IPC_STAT: case SEM_STAT: perms = SEM__GETATTR | SEM__ASSOCIATE; break; default: return 0; } err = ipc_has_perm(&sma->sem_perm, perms); return err; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton125100.00%1100.00%
Total125100.00%1100.00%


static int selinux_sem_semop(struct sem_array *sma, struct sembuf *sops, unsigned nsops, int alter) { u32 perms; if (alter) perms = SEM__READ | SEM__WRITE; else perms = SEM__READ; return ipc_has_perm(&sma->sem_perm, perms); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton51100.00%1100.00%
Total51100.00%1100.00%


static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag) { u32 av = 0; av = 0; if (flag & S_IRUGO) av |= IPC__UNIX_READ; if (flag & S_IWUGO) av |= IPC__UNIX_WRITE; if (av == 0) return 0; return ipc_has_perm(ipcp, av); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton60100.00%1100.00%
Total60100.00%1100.00%


static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid) { struct ipc_security_struct *isec = ipcp->security; *secid = isec->sid; }

Contributors

PersonTokensPropCommitsCommitProp
ahmed s. darwishahmed s. darwish31100.00%1100.00%
Total31100.00%1100.00%


static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode) { if (inode) inode_doinit_with_dentry(inode, dentry); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton27100.00%1100.00%
Total27100.00%1100.00%


static int selinux_getprocattr(struct task_struct *p, char *name, char **value) { const struct task_security_struct *__tsec; u32 sid; int error; unsigned len; if (current != p) { error = current_has_perm(p, PROCESS__GETATTR); if (error) return error; } rcu_read_lock(); __tsec = __task_cred(p)->security; if (!strcmp(name, "current")) sid = __tsec->sid; else if (!strcmp(name, "prev")) sid = __tsec->osid; else if (!strcmp(name, "exec")) sid = __tsec->exec_sid; else if (!strcmp(name, "fscreate")) sid = __tsec->create_sid; else if (!strcmp(name, "keycreate")) sid = __tsec->keycreate_sid; else if (!strcmp(name, "sockcreate")) sid = __tsec->sockcreate_sid; else goto invalid; rcu_read_unlock(); if (!sid) return 0; error = security_sid_to_context(sid, value, &len); if (error) return error; return len; invalid: rcu_read_unlock(); return -EINVAL; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton13461.47%114.29%
david howellsdavid howells3214.68%342.86%
al viroal viro209.17%114.29%
michael lemaymichael lemay167.34%114.29%
eric pariseric paris167.34%114.29%
Total218100.00%7100.00%


static int selinux_setprocattr(struct task_struct *p, char *name, void *value, size_t size) { struct task_security_struct *tsec; struct cred *new; u32 sid = 0, ptsid; int error; char *str = value; if (current != p) { /* SELinux only allows a process to change its own security attributes. */ return -EACCES; } /* * Basic control over ability to set these attributes at all. * current == p, but we'll pass them separately in case the * above restriction is ever removed. */ if (!strcmp(name, "exec")) error = current_has_perm(p, PROCESS__SETEXEC); else if (!strcmp(name, "fscreate")) error = current_has_perm(p, PROCESS__SETFSCREATE); else if (!strcmp(name, "keycreate")) error = current_has_perm(p, PROCESS__SETKEYCREATE); else if (!strcmp(name, "sockcreate")) error = current_has_perm(p, PROCESS__SETSOCKCREATE); else if (!strcmp(name, "current")) error = current_has_perm(p, PROCESS__SETCURRENT); else error = -EINVAL; if (error) return error; /* Obtain a SID for the context, if one was specified. */ if (size && str[1] && str[1] != '\n') { if (str[size-1] == '\n') { str[size-1] = 0; size--; } error = security_context_to_sid(value, size, &sid, GFP_KERNEL); if (error == -EINVAL && !strcmp(name, "fscreate")) { if (!capable(CAP_MAC_ADMIN)) { struct audit_buffer *ab; size_t audit_size; /* We strip a nul only if it is at the end, otherwise the * context contains a nul and we should audit that */ if (str[size - 1] == '\0') audit_size = size - 1; else audit_size = size; ab = audit_log_start(current->audit_context, GFP_ATOMIC, AUDIT_SELINUX_ERR); audit_log_format(ab, "op=fscreate invalid_context="); audit_log_n_untrustedstring(ab, value, audit_size); audit_log_end(ab); return error; } error = security_context_to_sid_force(value, size, &sid); } if (error) return error; } new = prepare_creds(); if (!new) return -ENOMEM; /* Permission checking based on the specified context is performed during the actual operation (execve, open/mkdir/...), when we know the full context of the operation. See selinux_bprm_set_creds for the execve checks and may_create for the file creation checks. The operation will then fail if the context is not permitted. */ tsec = new->security; if (!strcmp(name, "exec")) { tsec->exec_sid = sid; } else if (!strcmp(name, "fscreate")) { tsec->create_sid = sid; } else if (!strcmp(name, "keycreate")) { error = may_create_key(sid, p); if (error) goto abort_change; tsec->keycreate_sid = sid; } else if (!strcmp(name, "sockcreate")) { tsec->sockcreate_sid = sid; } else if (!strcmp(name, "current")) { error = -EINVAL; if (sid == 0) goto abort_change; /* Only allow single threaded processes to change context */ error = -EPERM; if (!current_is_single_threaded()) { error = security_bounded_transition(tsec->sid, sid); if (error) goto abort_change; } /* Check permissions for the transition. */ error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS, PROCESS__DYNTRANSITION, NULL); if (error) goto abort_change; /* Check for ptracing, and update the task SID if ok. Otherwise, leave SID unchanged and fail. */ ptsid = ptrace_parent_sid(p); if (ptsid != 0) { error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS, PROCESS__PTRACE, NULL); if (error) goto abort_change; } tsec->sid = sid; } else { error = -EINVAL; goto abort_change; } commit_creds(new); return size; abort_change: abort_creds(new); return error; }

Contributors

PersonTokensPropCommitsCommitProp
stephen d. smalleystephen d. smalley17728.78%320.00%
andrew mortonandrew morton16727.15%16.67%
eric pariseric paris10316.75%213.33%
david howellsdavid howells8613.98%320.00%
michael lemaymichael lemay518.29%16.67%
kaigai koheikaigai kohei172.76%16.67%
roland mcgrathroland mcgrath71.14%16.67%
paul moorepaul moore30.49%16.67%
nikolay aleksandrovnikolay aleksandrov20.33%16.67%
oleg nesterovoleg nesterov20.33%16.67%
Total615100.00%15100.00%


static int selinux_ismaclabel(const char *name) { return (strcmp(name, XATTR_SELINUX_SUFFIX) == 0); }

Contributors

PersonTokensPropCommitsCommitProp
david quigleydavid quigley23100.00%1100.00%
Total23100.00%1100.00%


static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen) { return security_sid_to_context(secid, secdata, seclen); }

Contributors

PersonTokensPropCommitsCommitProp
catherine zhangcatherine zhang28100.00%1100.00%
Total28100.00%1100.00%


static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid) { return security_context_to_sid(secdata, seclen, secid, GFP_KERNEL); }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells2893.33%266.67%
nikolay aleksandrovnikolay aleksandrov26.67%133.33%
Total30100.00%3100.00%


static void selinux_release_secctx(char *secdata, u32 seclen) { kfree(secdata); }

Contributors

PersonTokensPropCommitsCommitProp
catherine zhangcatherine zhang18100.00%1100.00%
Total18100.00%1100.00%


static void selinux_inode_invalidate_secctx(struct inode *inode) { struct inode_security_struct *isec = inode->i_security; mutex_lock(&isec->lock); isec->initialized = LABEL_INVALID; mutex_unlock(&isec->lock); }

Contributors

PersonTokensPropCommitsCommitProp
andreas gruenbacherandreas gruenbacher42100.00%1100.00%
Total42100.00%1100.00%

/* * called with inode->i_mutex locked */
static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen) { return selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, ctxlen, 0); }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley32100.00%1100.00%
Total32100.00%1100.00%

/* * called with inode->i_mutex locked */
static int selinux_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen) { return __vfs_setxattr_noperm(dentry, XATTR_NAME_SELINUX, ctx, ctxlen, 0); }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley32100.00%1100.00%
Total32100.00%1100.00%


static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen) { int len = 0; len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, true); if (len < 0) return len; *ctxlen = len; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
david p. quigleydavid p. quigley55100.00%1100.00%
Total55100.00%1100.00%

#ifdef CONFIG_KEYS
static int selinux_key_alloc(struct key *k, const struct cred *cred, unsigned long flags) { const struct task_security_struct *tsec; struct key_security_struct *ksec; ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL); if (!ksec) return -ENOMEM; tsec = cred->security; if (tsec->keycreate_sid) ksec->sid = tsec->keycreate_sid; else ksec->sid = tsec->sid; k->security = ksec; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
michael lemaymichael lemay7480.43%240.00%
david howellsdavid howells1819.57%360.00%
Total92100.00%5100.00%


static void selinux_key_free(struct key *k) { struct key_security_struct *ksec = k->security; k->security = NULL; kfree(ksec); }

Contributors

PersonTokensPropCommitsCommitProp
michael lemaymichael lemay31100.00%1100.00%
Total31100.00%1100.00%


static int selinux_key_permission(key_ref_t key_ref, const struct cred *cred, unsigned perm) { struct key *key; struct key_security_struct *ksec; u32 sid; /* if no specific permissions are requested, we skip the permission check. No serious, additional covert channels appear to be created. */ if (perm == 0) return 0; sid = cred_sid(cred); key = key_ref_to_ptr(key_ref); ksec = key->security; return avc_has_perm(sid, ksec->sid, SECCLASS_KEY, perm, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
michael lemaymichael lemay5368.83%125.00%
david howellsdavid howells2431.17%375.00%
Total77100.00%4100.00%


static int selinux_key_getsecurity(struct key *key, char **_buffer) { struct key_security_struct *ksec = key->security; char *context = NULL; unsigned len; int rc; rc = security_sid_to_context(ksec->sid, &context, &len); if (!rc) rc = len; *_buffer = context; return rc; }

Contributors

PersonTokensPropCommitsCommitProp
david howellsdavid howells69100.00%1100.00%
Total69100.00%1100.00%

#endif static struct security_hook_list selinux_hooks[] = { 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), LSM_HOOK_INIT(binder_transfer_file, selinux_binder_transfer_file), LSM_HOOK_INIT(ptrace_access_check, selinux_ptrace_access_check), LSM_HOOK_INIT(ptrace_traceme, selinux_ptrace_traceme), LSM_HOOK_INIT(capget, selinux_capget), LSM_HOOK_INIT(capset, selinux_capset), LSM_HOOK_INIT(capable, selinux_capable), LSM_HOOK_INIT(quotactl, selinux_quotactl), LSM_HOOK_INIT(quota_on, selinux_quota_on), LSM_HOOK_INIT(syslog, selinux_syslog), LSM_HOOK_INIT(vm_enough_memory, selinux_vm_enough_memory), LSM_HOOK_INIT(netlink_send, selinux_netlink_send), LSM_HOOK_INIT(bprm_set_creds, selinux_bprm_set_creds), LSM_HOOK_INIT(bprm_committing_creds, selinux_bprm_committing_creds), LSM_HOOK_INIT(bprm_committed_creds, selinux_bprm_committed_creds), LSM_HOOK_INIT(bprm_secureexec, selinux_bprm_secureexec), LSM_HOOK_INIT(sb_alloc_security, selinux_sb_alloc_security), LSM_HOOK_INIT(sb_free_security, selinux_sb_free_security), LSM_HOOK_INIT(sb_copy_data, selinux_sb_copy_data), LSM_HOOK_INIT(sb_remount, selinux_sb_remount), LSM_HOOK_INIT(sb_kern_mount, selinux_sb_kern_mount), LSM_HOOK_INIT(sb_show_options, selinux_sb_show_options), LSM_HOOK_INIT(sb_statfs, selinux_sb_statfs), LSM_HOOK_INIT(sb_mount, selinux_mount), LSM_HOOK_INIT(sb_umount, selinux_umount), LSM_HOOK_INIT(sb_set_mnt_opts, selinux_set_mnt_opts), LSM_HOOK_INIT(sb_clone_mnt_opts, selinux_sb_clone_mnt_opts), LSM_HOOK_INIT(sb_parse_opts_str, selinux_parse_opts_str), LSM_HOOK_INIT(dentry_init_security, selinux_dentry_init_security), LSM_HOOK_INIT(inode_alloc_security, selinux_inode_alloc_security), LSM_HOOK_INIT(inode_free_security, selinux_inode_free_security), LSM_HOOK_INIT(inode_init_security, selinux_inode_init_security), LSM_HOOK_INIT(inode_create, selinux_inode_create), LSM_HOOK_INIT(inode_link, selinux_inode_link), LSM_HOOK_INIT(inode_unlink, selinux_inode_unlink), LSM_HOOK_INIT(inode_symlink, selinux_inode_symlink), LSM_HOOK_INIT(inode_mkdir, selinux_inode_mkdir), LSM_HOOK_INIT(inode_rmdir, selinux_inode_rmdir), LSM_HOOK_INIT(inode_mknod, selinux_inode_mknod), LSM_HOOK_INIT(inode_rename, selinux_inode_rename), LSM_HOOK_INIT(inode_readlink, selinux_inode_readlink), LSM_HOOK_INIT(inode_follow_link, selinux_inode_follow_link), LSM_HOOK_INIT(inode_permission, selinux_inode_permission), LSM_HOOK_INIT(inode_setattr, selinux_inode_setattr), LSM_HOOK_INIT(inode_getattr, selinux_inode_getattr), LSM_HOOK_INIT(inode_setxattr, selinux_inode_setxattr), LSM_HOOK_INIT(inode_post_setxattr, selinux_inode_post_setxattr), LSM_HOOK_INIT(inode_getxattr, selinux_inode_getxattr), LSM_HOOK_INIT(inode_listxattr, selinux_inode_listxattr), LSM_HOOK_INIT(inode_removexattr, selinux_inode_removexattr), LSM_HOOK_INIT(inode_getsecurity, selinux_inode_getsecurity), LSM_HOOK_INIT(inode_setsecurity, selinux_inode_setsecurity), LSM_HOOK_INIT(inode_listsecurity, selinux_inode_listsecurity), LSM_HOOK_INIT(inode_getsecid, selinux_inode_getsecid), LSM_HOOK_INIT(file_permission, selinux_file_permission), LSM_HOOK_INIT(file_alloc_security, selinux_file_alloc_security), LSM_HOOK_INIT(file_free_security, selinux_file_free_security), LSM_HOOK_INIT(file_ioctl, selinux_file_ioctl), LSM_HOOK_INIT(mmap_file, selinux_mmap_file), LSM_HOOK_INIT(mmap_addr, selinux_mmap_addr), LSM_HOOK_INIT(file_mprotect, selinux_file_mprotect), LSM_HOOK_INIT(file_lock, selinux_file_lock), LSM_HOOK_INIT(file_fcntl, selinux_file_fcntl), LSM_HOOK_INIT(file_set_fowner, selinux_file_set_fowner), LSM_HOOK_INIT(file_send_sigiotask, selinux_file_send_sigiotask), LSM_HOOK_INIT(file_receive, selinux_file_receive), LSM_HOOK_INIT(file_open, selinux_file_open), LSM_HOOK_INIT(task_create, selinux_task_create), LSM_HOOK_INIT(cred_alloc_blank, selinux_cred_alloc_blank), LSM_HOOK_INIT(cred_free, selinux_cred_free), LSM_HOOK_INIT(cred_prepare, selinux_cred_prepare), LSM_HOOK_INIT(cred_transfer, selinux_cred_transfer), LSM_HOOK_INIT(kernel_act_as, selinux_kernel_act_as), LSM_HOOK_INIT(kernel_create_files_as, selinux_kernel_create_files_as), LSM_HOOK_INIT(kernel_module_request, selinux_kernel_module_request), LSM_HOOK_INIT(kernel_read_file, selinux_kernel_read_file), LSM_HOOK_INIT(task_setpgid, selinux_task_setpgid), LSM_HOOK_INIT(task_getpgid, selinux_task_getpgid), LSM_HOOK_INIT(task_getsid, selinux_task_getsid), LSM_HOOK_INIT(task_getsecid, selinux_task_getsecid), LSM_HOOK_INIT(task_setnice, selinux_task_setnice), LSM_HOOK_INIT(task_setioprio, selinux_task_setioprio), LSM_HOOK_INIT(task_getioprio, selinux_task_getioprio), LSM_HOOK_INIT(task_setrlimit, selinux_task_setrlimit), LSM_HOOK_INIT(task_setscheduler, selinux_task_setscheduler), LSM_HOOK_INIT(task_getscheduler, selinux_task_getscheduler), LSM_HOOK_INIT(task_movememory, selinux_task_movememory), LSM_HOOK_INIT(task_kill, selinux_task_kill), LSM_HOOK_INIT(task_wait, selinux_task_wait), LSM_HOOK_INIT(task_to_inode, selinux_task_to_inode), LSM_HOOK_INIT(ipc_permission, selinux_ipc_permission), LSM_HOOK_INIT(ipc_getsecid, selinux_ipc_getsecid), LSM_HOOK_INIT(msg_msg_alloc_security, selinux_msg_msg_alloc_security), LSM_HOOK_INIT(msg_msg_free_security, selinux_msg_msg_free_security), LSM_HOOK_INIT(msg_queue_alloc_security, selinux_msg_queue_alloc_security), LSM_HOOK_INIT(msg_queue_free_security, selinux_msg_queue_free_security), LSM_HOOK_INIT(msg_queue_associate, selinux_msg_queue_associate), LSM_HOOK_INIT(msg_queue_msgctl, selinux_msg_queue_msgctl), LSM_HOOK_INIT(msg_queue_msgsnd, selinux_msg_queue_msgsnd), LSM_HOOK_INIT(msg_queue_msgrcv, selinux_msg_queue_msgrcv), LSM_HOOK_INIT(shm_alloc_security, selinux_shm_alloc_security), LSM_HOOK_INIT(shm_free_security, selinux_shm_free_security), LSM_HOOK_INIT(shm_associate, selinux_shm_associate), LSM_HOOK_INIT(shm_shmctl, selinux_shm_shmctl), LSM_HOOK_INIT(shm_shmat, selinux_shm_shmat), LSM_HOOK_INIT(sem_alloc_security, selinux_sem_alloc_security), LSM_HOOK_INIT(sem_free_security, selinux_sem_free_security), LSM_HOOK_INIT(sem_associate, selinux_sem_associate), LSM_HOOK_INIT(sem_semctl, selinux_sem_semctl), LSM_HOOK_INIT(sem_semop, selinux_sem_semop), LSM_HOOK_INIT(d_instantiate, selinux_d_instantiate), LSM_HOOK_INIT(getprocattr, selinux_getprocattr), LSM_HOOK_INIT(setprocattr, selinux_setprocattr), LSM_HOOK_INIT(ismaclabel, selinux_ismaclabel), LSM_HOOK_INIT(secid_to_secctx, selinux_secid_to_secctx), LSM_HOOK_INIT(secctx_to_secid, selinux_secctx_to_secid), LSM_HOOK_INIT(release_secctx, selinux_release_secctx), LSM_HOOK_INIT(inode_invalidate_secctx, selinux_inode_invalidate_secctx), LSM_HOOK_INIT(inode_notifysecctx, selinux_inode_notifysecctx), LSM_HOOK_INIT(inode_setsecctx, selinux_inode_setsecctx), LSM_HOOK_INIT(inode_getsecctx, selinux_inode_getsecctx), LSM_HOOK_INIT(unix_stream_connect, selinux_socket_unix_stream_connect), LSM_HOOK_INIT(unix_may_send, selinux_socket_unix_may_send), LSM_HOOK_INIT(socket_create, selinux_socket_create), LSM_HOOK_INIT(socket_post_create, selinux_socket_post_create), LSM_HOOK_INIT(socket_bind, selinux_socket_bind), LSM_HOOK_INIT(socket_connect, selinux_socket_connect), LSM_HOOK_INIT(socket_listen, selinux_socket_listen), LSM_HOOK_INIT(socket_accept, selinux_socket_accept), LSM_HOOK_INIT(socket_sendmsg, selinux_socket_sendmsg), LSM_HOOK_INIT(socket_recvmsg, selinux_socket_recvmsg), LSM_HOOK_INIT(socket_getsockname, selinux_socket_getsockname), LSM_HOOK_INIT(socket_getpeername, selinux_socket_getpeername), LSM_HOOK_INIT(socket_getsockopt, selinux_socket_getsockopt), LSM_HOOK_INIT(socket_setsockopt, selinux_socket_setsockopt), LSM_HOOK_INIT(socket_shutdown, selinux_socket_shutdown), LSM_HOOK_INIT(socket_sock_rcv_skb, selinux_socket_sock_rcv_skb), LSM_HOOK_INIT(socket_getpeersec_stream, selinux_socket_getpeersec_stream), LSM_HOOK_INIT(socket_getpeersec_dgram, selinux_socket_getpeersec_dgram), LSM_HOOK_INIT(sk_alloc_security, selinux_sk_alloc_security), LSM_HOOK_INIT(sk_free_security, selinux_sk_free_security), LSM_HOOK_INIT(sk_clone_security, selinux_sk_clone_security), LSM_HOOK_INIT(sk_getsecid, selinux_sk_getsecid), LSM_HOOK_INIT(sock_graft, selinux_sock_graft), LSM_HOOK_INIT(inet_conn_request, selinux_inet_conn_request), LSM_HOOK_INIT(inet_csk_clone, selinux_inet_csk_clone), LSM_HOOK_INIT(inet_conn_established, selinux_inet_conn_established), LSM_HOOK_INIT(secmark_relabel_packet, selinux_secmark_relabel_packet), LSM_HOOK_INIT(secmark_refcount_inc, selinux_secmark_refcount_inc), LSM_HOOK_INIT(secmark_refcount_dec, selinux_secmark_refcount_dec), LSM_HOOK_INIT(req_classify_flow, selinux_req_classify_flow), LSM_HOOK_INIT(tun_dev_alloc_security, selinux_tun_dev_alloc_security), LSM_HOOK_INIT(tun_dev_free_security, selinux_tun_dev_free_security), LSM_HOOK_INIT(tun_dev_create, selinux_tun_dev_create), LSM_HOOK_INIT(tun_dev_attach_queue, selinux_tun_dev_attach_queue), LSM_HOOK_INIT(tun_dev_attach, selinux_tun_dev_attach), LSM_HOOK_INIT(tun_dev_open, selinux_tun_dev_open), #ifdef CONFIG_SECURITY_NETWORK_XFRM LSM_HOOK_INIT(xfrm_policy_alloc_security, selinux_xfrm_policy_alloc), LSM_HOOK_INIT(xfrm_policy_clone_security, selinux_xfrm_policy_clone), LSM_HOOK_INIT(xfrm_policy_free_security, selinux_xfrm_policy_free), LSM_HOOK_INIT(xfrm_policy_delete_security, selinux_xfrm_policy_delete), LSM_HOOK_INIT(xfrm_state_alloc, selinux_xfrm_state_alloc), LSM_HOOK_INIT(xfrm_state_alloc_acquire, selinux_xfrm_state_alloc_acquire), LSM_HOOK_INIT(xfrm_state_free_security, selinux_xfrm_state_free), LSM_HOOK_INIT(xfrm_state_delete_security, selinux_xfrm_state_delete), LSM_HOOK_INIT(xfrm_policy_lookup, selinux_xfrm_policy_lookup), LSM_HOOK_INIT(xfrm_state_pol_flow_match, selinux_xfrm_state_pol_flow_match), LSM_HOOK_INIT(xfrm_decode_session, selinux_xfrm_decode_session), #endif #ifdef CONFIG_KEYS LSM_HOOK_INIT(key_alloc, selinux_key_alloc), LSM_HOOK_INIT(key_free, selinux_key_free), LSM_HOOK_INIT(key_permission, selinux_key_permission), LSM_HOOK_INIT(key_getsecurity, selinux_key_getsecurity), #endif #ifdef CONFIG_AUDIT LSM_HOOK_INIT(audit_rule_init, selinux_audit_rule_init), LSM_HOOK_INIT(audit_rule_known, selinux_audit_rule_known), LSM_HOOK_INIT(audit_rule_match, selinux_audit_rule_match), LSM_HOOK_INIT(audit_rule_free, selinux_audit_rule_free), #endif };
static __init int selinux_init(void) { if (!security_module_enable("selinux")) { selinux_enabled = 0; return 0; } if (!selinux_enabled) { printk(KERN_INFO "SELinux: Disabled at boot.\n"); return 0; } printk(KERN_INFO "SELinux: Initializing.\n"); /* Set the security state for the initial task. */ cred_init_security(); default_noexec = !(VM_DATA_DEFAULT_FLAGS & VM_EXEC); sel_inode_cache = kmem_cache_create("selinux_inode_security", sizeof(struct inode_security_struct), 0, SLAB_PANIC, NULL); file_security_cache = kmem_cache_create("selinux_file_security", sizeof(struct file_security_struct), 0, SLAB_PANIC, NULL); avc_init(); security_add_hooks(selinux_hooks, ARRAY_SIZE(selinux_hooks)); if (avc_add_callback(selinux_netcache_avc_callback, AVC_CALLBACK_RESET)) panic("SELinux: Unable to register AVC netcache callback\n"); if (selinux_enforcing) printk(KERN_DEBUG "SELinux: Starting in enforcing mode\n"); else printk(KERN_DEBUG "SELinux: Starting in permissive mode\n"); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5739.04%325.00%
sangwoo parksangwoo park1913.01%18.33%
james morrisjames morris1913.01%18.33%
ahmed s. darwishahmed s. darwish1610.96%18.33%
paul moorepaul moore149.59%18.33%
stephen d. smalleystephen d. smalley106.85%216.67%
casey schauflercasey schaufler74.79%18.33%
david howellsdavid howells21.37%18.33%
eric pariseric paris21.37%18.33%
Total146100.00%12100.00%


static void delayed_superblock_init(struct super_block *sb, void *unused) { superblock_doinit(sb, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
al viroal viro22100.00%1100.00%
Total22100.00%1100.00%


void selinux_complete_init(void) { printk(KERN_DEBUG "SELinux: Completing initialization.\n"); /* Set up any superblocks initialized prior to the policy load. */ printk(KERN_DEBUG "SELinux: Setting up existing superblocks.\n"); iterate_supers(delayed_superblock_init, NULL); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton2385.19%250.00%
al viroal viro27.41%125.00%
eric pariseric paris27.41%125.00%
Total27100.00%4100.00%

/* SELinux requires early initialization in order to label all processes and objects when they are created. */ security_initcall(selinux_init); #if defined(CONFIG_NETFILTER) static struct nf_hook_ops selinux_nf_ops[] = { { .hook = selinux_ipv4_postroute, .pf = NFPROTO_IPV4, .hooknum = NF_INET_POST_ROUTING, .priority = NF_IP_PRI_SELINUX_LAST, }, { .hook = selinux_ipv4_forward, .pf = NFPROTO_IPV4, .hooknum = NF_INET_FORWARD, .priority = NF_IP_PRI_SELINUX_FIRST, }, { .hook = selinux_ipv4_output, .pf = NFPROTO_IPV4, .hooknum = NF_INET_LOCAL_OUT, .priority = NF_IP_PRI_SELINUX_FIRST, }, #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) { .hook = selinux_ipv6_postroute, .pf = NFPROTO_IPV6, .hooknum = NF_INET_POST_ROUTING, .priority = NF_IP6_PRI_SELINUX_LAST, }, { .hook = selinux_ipv6_forward, .pf = NFPROTO_IPV6, .hooknum = NF_INET_FORWARD, .priority = NF_IP6_PRI_SELINUX_FIRST, }, #endif /* IPV6 */ };
static int __init selinux_nf_ip_init(void) { int err; if (!selinux_enabled) return 0; printk(KERN_DEBUG "SELinux: Registering netfilter hooks\n"); err = nf_register_hooks(selinux_nf_ops, ARRAY_SIZE(selinux_nf_ops)); if (err) panic("SELinux: nf_register_hooks: error %d\n", err); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton3771.15%233.33%
jiri pirkojiri pirko713.46%116.67%
alexey dobriyanalexey dobriyan59.62%116.67%
paul moorepaul moore23.85%116.67%
eric pariseric paris11.92%116.67%
Total52100.00%6100.00%

__initcall(selinux_nf_ip_init); #ifdef CONFIG_SECURITY_SELINUX_DISABLE
static void selinux_nf_ip_exit(void) { printk(KERN_DEBUG "SELinux: Unregistering netfilter hooks\n"); nf_unregister_hooks(selinux_nf_ops, ARRAY_SIZE(selinux_nf_ops)); }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1666.67%120.00%
alexey dobriyanalexey dobriyan416.67%120.00%
jiri pirkojiri pirko28.33%120.00%
paul moorepaul moore14.17%120.00%
eric pariseric paris14.17%120.00%
Total24100.00%5100.00%

#endif #else /* CONFIG_NETFILTER */ #ifdef CONFIG_SECURITY_SELINUX_DISABLE #define selinux_nf_ip_exit() #endif #endif /* CONFIG_NETFILTER */ #ifdef CONFIG_SECURITY_SELINUX_DISABLE static int selinux_disabled;
int selinux_disable(void) { if (ss_initialized) { /* Not permitted after initial policy load. */ return -EINVAL; } if (selinux_disabled) { /* Only do this once. */ return -EINVAL; } printk(KERN_INFO "SELinux: Disabled at runtime.\n"); selinux_disabled = 1; selinux_enabled = 0; 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(); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton5175.00%125.00%
casey schauflercasey schaufler913.24%125.00%
eric pariseric paris45.88%125.00%
stephen d. smalleystephen d. smalley45.88%125.00%
Total68100.00%4100.00%

#endif

Overall Contributors

PersonTokensPropCommitsCommitProp
andrew mortonandrew morton1014637.42%286.31%
eric pariseric paris444016.38%7115.99%
paul moorepaul moore26379.73%5011.26%
david howellsdavid howells21057.76%296.53%
stephen d. smalleystephen d. smalley17476.44%5311.94%
james morrisjames morris8012.95%224.95%
casey schauflercasey schaufler7502.77%30.68%
david p. quigleydavid p. quigley4791.77%92.03%
venkat yekkiralavenkat yekkirala4581.69%81.80%
andreas gruenbacherandreas gruenbacher3971.46%51.13%
jeff vander stoepjeff vander stoep3861.42%30.68%
michael lemaymichael lemay2831.04%30.68%
al viroal viro2540.94%286.31%
jeff laytonjeff layton2120.78%40.90%
david quigleydavid quigley2030.75%51.13%
david s. millerdavid s. miller1560.58%51.13%
serge hallynserge hallyn1420.52%51.13%
catherine zhangcatherine zhang1240.46%40.90%
cory olmocory olmo1200.44%10.23%
ahmed s. darwishahmed s. darwish1040.38%30.68%
harry ciaoharry ciao880.32%10.23%
lorenzo hernandez garcia-hierrolorenzo hernandez garcia-hierro860.32%20.45%
yuichi nakamurayuichi nakamura860.32%10.23%
eric w. biedermaneric w. biederman700.26%51.13%
neil brownneil brown700.26%20.45%
linus torvaldslinus torvalds630.23%30.68%
steven rostedtsteven rostedt420.15%10.23%
trent jaegertrent jaeger420.15%10.23%
lucian adrian grijinculucian adrian grijincu400.15%10.23%
oleg nesterovoleg nesterov400.15%51.13%
thomas liuthomas liu350.13%10.23%
christopher j. pebenitochristopher j. pebenito320.12%20.45%
americo wangamerico wang310.11%10.23%
mark salyzynmark salyzyn300.11%10.23%
sangwoo parksangwoo park300.11%10.23%
darrel goeddeldarrel goeddel240.09%10.23%
stephen hemmingerstephen hemminger230.08%20.45%
eric dumazeteric dumazet220.08%40.90%
nick pigginnick piggin210.08%20.45%
kaigai koheikaigai kohei170.06%10.23%
kees cookkees cook170.06%30.68%
roland mcgrathroland mcgrath150.06%30.68%
jiri pirkojiri pirko140.05%10.23%
vladis dronovvladis dronov130.05%10.23%
alexey dobriyanalexey dobriyan120.04%20.45%
gerald schaefergerald schaefer120.04%10.23%
nikolay aleksandrovnikolay aleksandrov120.04%10.23%
waiman longwaiman long120.04%10.23%
jiri slabyjiri slaby100.04%30.68%
jan blunckjan blunck100.04%20.45%
arnaldo carvalho de meloarnaldo carvalho de melo90.03%20.45%
peter zijlstrapeter zijlstra90.03%10.23%
steffen klassertsteffen klassert80.03%10.23%
marek milkovicmarek milkovic70.03%10.23%
adrian bunkadrian bunk70.03%40.90%
patrick mchardypatrick mchardy70.03%20.45%
david woodhousedavid woodhouse70.03%10.23%
tetsuo handatetsuo handa70.03%20.45%
j. bruce fieldsj. bruce fields60.02%10.23%
jesse grossjesse gross60.02%10.23%
peter hurleypeter hurley60.02%10.23%
alan coxalan cox60.02%20.45%
chad hansonchad hanson50.02%10.23%
alban crequyalban crequy50.02%10.23%
rasmus villemoesrasmus villemoes40.01%10.23%
jan karajan kara40.01%10.23%
robert p. j. dayrobert p. j. day40.01%20.45%
paul gortmakerpaul gortmaker30.01%10.23%
cyrill gorcunovcyrill gorcunov30.01%10.23%
chris wrightchris wright30.01%30.68%
frank mayharfrank mayhar30.01%10.23%
akinobu mitaakinobu mita30.01%10.23%
harvey harrisonharvey harrison30.01%10.23%
richard guy briggsrichard guy briggs30.01%10.23%
ingo molnaringo molnar30.01%10.23%
dustin kirklanddustin kirkland20.01%10.23%
hong zhi guohong zhi guo20.01%10.23%
dipankar sarmadipankar sarma20.01%10.23%
jingoo hanjingoo han20.01%10.23%
christoph lameterchristoph lameter20.01%10.23%
andy lutomirskiandy lutomirski10.00%10.23%
josef bacikjosef bacik10.00%10.23%
steve grubbsteve grubb10.00%10.23%
satyam sharmasatyam sharma10.00%10.23%
steven whitehousesteven whitehouse10.00%10.23%
pavel emelianovpavel emelianov10.00%10.23%
arun sharmaarun sharma10.00%10.23%
josef sipekjosef sipek10.00%10.23%
geliang tanggeliang tang10.00%10.23%
Total27113100.00%444100.00%
Directory: security/selinux
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}