security/selinux/hooks.c

   1 /*
   2  *  NSA Security-Enhanced Linux (SELinux) security module
   3  *
   4  *  This file contains the SELinux hook function implementations.
   5  *
   6  *  Authors:  Stephen Smalley, <sds@epoch.ncsc.mil>
   7  *            Chris Vance, <cvance@nai.com>
   8  *            Wayne Salamon, <wsalamon@nai.com>
   9  *            James Morris <jmorris@redhat.com>
  10  *
  11  *  Copyright (C) 2001,2002 Networks Associates Technology, Inc.
  12  *  Copyright (C) 2003-2008 Red Hat, Inc., James Morris <jmorris@redhat.com>
  13  *                                         Eric Paris <eparis@redhat.com>
  14  *  Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
  15  *                          <dgoeddel@trustedcs.com>
  16  *  Copyright (C) 2006, 2007, 2009 Hewlett-Packard Development Company, L.P.
  17  *      Paul Moore <paul.moore@hp.com>
  18  *  Copyright (C) 2007 Hitachi Software Engineering Co., Ltd.
  19  *                     Yuichi Nakamura <ynakam@hitachisoft.jp>
  20  *
  21  *      This program is free software; you can redistribute it and/or modify
  22  *      it under the terms of the GNU General Public License version 2,
  23  *      as published by the Free Software Foundation.
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/kd.h>
  28 #include <linux/kernel.h>
  29 #include <linux/tracehook.h>
  30 #include <linux/errno.h>
  31 #include <linux/ext2_fs.h>
  32 #include <linux/sched.h>
  33 #include <linux/security.h>
  34 #include <linux/xattr.h>
  35 #include <linux/capability.h>
  36 #include <linux/unistd.h>
  37 #include <linux/mm.h>
  38 #include <linux/mman.h>
  39 #include <linux/slab.h>
  40 #include <linux/pagemap.h>
  41 #include <linux/proc_fs.h>
  42 #include <linux/swap.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/syscalls.h>
  45 #include <linux/dcache.h>
  46 #include <linux/file.h>
  47 #include <linux/fdtable.h>
  48 #include <linux/namei.h>
  49 #include <linux/mount.h>
  50 #include <linux/netfilter_ipv4.h>
  51 #include <linux/netfilter_ipv6.h>
  52 #include <linux/tty.h>
  53 #include <net/icmp.h>
  54 #include <net/ip.h>             /* for local_port_range[] */
  55 #include <net/tcp.h>            /* struct or_callable used in sock_rcv_skb */
  56 #include <net/net_namespace.h>
  57 #include <net/netlabel.h>
  58 #include <linux/uaccess.h>
  59 #include <asm/ioctls.h>
  60 #include <asm/atomic.h>
  61 #include <linux/bitops.h>
  62 #include <linux/interrupt.h>
  63 #include <linux/netdevice.h>    /* for network interface checks */
  64 #include <linux/netlink.h>
  65 #include <linux/tcp.h>
  66 #include <linux/udp.h>
  67 #include <linux/dccp.h>
  68 #include <linux/quota.h>
  69 #include <linux/un.h>           /* for Unix socket types */
  70 #include <net/af_unix.h>        /* for Unix socket types */
  71 #include <linux/parser.h>
  72 #include <linux/nfs_mount.h>
  73 #include <net/ipv6.h>
  74 #include <linux/hugetlb.h>
  75 #include <linux/personality.h>
  76 #include <linux/audit.h>
  77 #include <linux/string.h>
  78 #include <linux/selinux.h>
  79 #include <linux/mutex.h>
  80 #include <linux/posix-timers.h>
  81 #include <linux/syslog.h>
  82
  83 #include "avc.h"
  84 #include "objsec.h"
  85 #include "netif.h"
  86 #include "netnode.h"
  87 #include "netport.h"
  88 #include "xfrm.h"
  89 #include "netlabel.h"
  90 #include "audit.h"
  91
  92 #define NUM_SEL_MNT_OPTS 5
  93
  94 extern int selinux_nlmsg_lookup(u16 sclass, u16 nlmsg_type, u32 *perm);
  95 extern struct security_operations *security_ops;
  96
  97 /* SECMARK reference count */
  98 atomic_t selinux_secmark_refcount = ATOMIC_INIT(0);
  99
 100 #ifdef CONFIG_SECURITY_SELINUX_DEVELOP
 101 int selinux_enforcing;
 102
 103 static int __init enforcing_setup(char *str)
 104 {
 105         unsigned long enforcing;
 106         if (!strict_strtoul(str, 0, &enforcing))
 107                 selinux_enforcing = enforcing ? 1 : 0;
 108         return 1;
 109 }
 110 __setup("enforcing=", enforcing_setup);
 111 #endif
 112
 113 #ifdef CONFIG_SECURITY_SELINUX_BOOTPARAM
 114 int selinux_enabled = CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE;
 115
 116 static int __init selinux_enabled_setup(char *str)
 117 {
 118         unsigned long enabled;
 119         if (!strict_strtoul(str, 0, &enabled))
 120                 selinux_enabled = enabled ? 1 : 0;
 121         return 1;
 122 }
 123 __setup("selinux=", selinux_enabled_setup);
 124 #else
 125 int selinux_enabled = 1;
 126 #endif
 127
 128 static struct kmem_cache *sel_inode_cache;
 129
 130 /**
 131  * selinux_secmark_enabled - Check to see if SECMARK is currently enabled
 132  *
 133  * Description:
 134  * This function checks the SECMARK reference counter to see if any SECMARK
 135  * targets are currently configured, if the reference counter is greater than
 136  * zero SECMARK is considered to be enabled.  Returns true (1) if SECMARK is
 137  * enabled, false (0) if SECMARK is disabled.
 138  *
 139  */
 140 static int selinux_secmark_enabled(void)
 141 {
 142         return (atomic_read(&selinux_secmark_refcount) > 0);
 143 }
 144
 145 /*
 146  * initialise the security for the init task
 147  */
 148 static void cred_init_security(void)
 149 {
 150         struct cred *cred = (struct cred *) current->real_cred;
 151         struct task_security_struct *tsec;
 152
 153         tsec = kzalloc(sizeof(struct task_security_struct), GFP_KERNEL);
 154         if (!tsec)
 155                 panic("SELinux:  Failed to initialize initial task.\n");
 156
 157         tsec->osid = tsec->sid = SECINITSID_KERNEL;
 158         cred->security = tsec;
 159 }
 160
 161 /*
 162  * get the security ID of a set of credentials
 163  */
 164 static inline u32 cred_sid(const struct cred *cred)
 165 {
 166         const struct task_security_struct *tsec;
 167
 168         tsec = cred->security;
 169         return tsec->sid;
 170 }
 171
 172 /*
 173  * get the objective security ID of a task
 174  */
 175 static inline u32 task_sid(const struct task_struct *task)
 176 {
 177         u32 sid;
 178
 179         rcu_read_lock();
 180         sid = cred_sid(__task_cred(task));
 181         rcu_read_unlock();
 182         return sid;
 183 }
 184
 185 /*
 186  * get the subjective security ID of the current task
 187  */
 188 static inline u32 current_sid(void)
 189 {
 190         const struct task_security_struct *tsec = current_security();
 191
 192         return tsec->sid;
 193 }
 194
 195 /* Allocate and free functions for each kind of security blob. */
 196
 197 static int inode_alloc_security(struct inode *inode)
 198 {
 199         struct inode_security_struct *isec;
 200         u32 sid = current_sid();
 201
 202         isec = kmem_cache_zalloc(sel_inode_cache, GFP_NOFS);
 203         if (!isec)
 204                 return -ENOMEM;
 205
 206         mutex_init(&isec->lock);
 207         INIT_LIST_HEAD(&isec->list);
 208         isec->inode = inode;
 209         isec->sid = SECINITSID_UNLABELED;
 210         isec->sclass = SECCLASS_FILE;
 211         isec->task_sid = sid;
 212         inode->i_security = isec;
 213
 214         return 0;
 215 }
 216
 217 static void inode_free_security(struct inode *inode)
 218 {
 219         struct inode_security_struct *isec = inode->i_security;
 220         struct superblock_security_struct *sbsec = inode->i_sb->s_security;
 221
 222         spin_lock(&sbsec->isec_lock);
 223         if (!list_empty(&isec->list))
 224                 list_del_init(&isec->list);
 225         spin_unlock(&sbsec->isec_lock);
 226
 227         inode->i_security = NULL;
 228         kmem_cache_free(sel_inode_cache, isec);
 229 }
 230
 231 static int file_alloc_security(struct file *file)
 232 {
 233         struct file_security_struct *fsec;
 234         u32 sid = current_sid();
 235
 236         fsec = kzalloc(sizeof(struct file_security_struct), GFP_KERNEL);
 237         if (!fsec)
 238                 return -ENOMEM;
 239
 240         fsec->sid = sid;
 241         fsec->fown_sid = sid;
 242         file->f_security = fsec;
 243
 244         return 0;
 245 }
 246
 247 static void file_free_security(struct file *file)
 248 {
 249         struct file_security_struct *fsec = file->f_security;
 250         file->f_security = NULL;
 251         kfree(fsec);
 252 }
 253
 254 static int superblock_alloc_security(struct super_block *sb)
 255 {
 256         struct superblock_security_struct *sbsec;
 257
 258         sbsec = kzalloc(sizeof(struct superblock_security_struct), GFP_KERNEL);
 259         if (!sbsec)
 260                 return -ENOMEM;
 261
 262         mutex_init(&sbsec->lock);
 263         INIT_LIST_HEAD(&sbsec->isec_head);
 264         spin_lock_init(&sbsec->isec_lock);
 265         sbsec->sb = sb;
 266         sbsec->sid = SECINITSID_UNLABELED;
 267         sbsec->def_sid = SECINITSID_FILE;
 268         sbsec->mntpoint_sid = SECINITSID_UNLABELED;
 269         sb->s_security = sbsec;
 270
 271         return 0;
 272 }
 273
 274 static void superblock_free_security(struct super_block *sb)
 275 {
 276         struct superblock_security_struct *sbsec = sb->s_security;
 277         sb->s_security = NULL;
 278         kfree(sbsec);
 279 }
 280
 281 /* The security server must be initialized before
 282    any labeling or access decisions can be provided. */
 283 extern int ss_initialized;
 284
 285 /* The file system's label must be initialized prior to use. */
 286
 287 static const char *labeling_behaviors[6] = {
 288         "uses xattr",
 289         "uses transition SIDs",
 290         "uses task SIDs",
 291         "uses genfs_contexts",
 292         "not configured for labeling",
 293         "uses mountpoint labeling",
 294 };
 295
 296 static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry);
 297
 298 static inline int inode_doinit(struct inode *inode)
 299 {
 300         return inode_doinit_with_dentry(inode, NULL);
 301 }
 302
 303 enum {
 304         Opt_error = -1,
 305         Opt_context = 1,
 306         Opt_fscontext = 2,
 307         Opt_defcontext = 3,
 308         Opt_rootcontext = 4,
 309         Opt_labelsupport = 5,
 310 };
 311
 312 static const match_table_t tokens = {
 313         {Opt_context, CONTEXT_STR "%s"},
 314         {Opt_fscontext, FSCONTEXT_STR "%s"},
 315         {Opt_defcontext, DEFCONTEXT_STR "%s"},
 316         {Opt_rootcontext, ROOTCONTEXT_STR "%s"},
 317         {Opt_labelsupport, LABELSUPP_STR},
 318         {Opt_error, NULL},
 319 };
 320
 321 #define SEL_MOUNT_FAIL_MSG "SELinux:  duplicate or incompatible mount options\n"
 322
 323 static int may_context_mount_sb_relabel(u32 sid,
 324                         struct superblock_security_struct *sbsec,
 325                         const struct cred *cred)
 326 {
 327         const struct task_security_struct *tsec = cred->security;
 328         int rc;
 329
 330         rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
 331                           FILESYSTEM__RELABELFROM, NULL);
 332         if (rc)
 333                 return rc;
 334
 335         rc = avc_has_perm(tsec->sid, sid, SECCLASS_FILESYSTEM,
 336                           FILESYSTEM__RELABELTO, NULL);
 337         return rc;
 338 }
 339
 340 static int may_context_mount_inode_relabel(u32 sid,
 341                         struct superblock_security_struct *sbsec,
 342                         const struct cred *cred)
 343 {
 344         const struct task_security_struct *tsec = cred->security;
 345         int rc;
 346         rc = avc_has_perm(tsec->sid, sbsec->sid, SECCLASS_FILESYSTEM,
 347                           FILESYSTEM__RELABELFROM, NULL);
 348         if (rc)
 349                 return rc;
 350
 351         rc = avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM,
 352                           FILESYSTEM__ASSOCIATE, NULL);
 353         return rc;
 354 }
 355
 356 static int sb_finish_set_opts(struct super_block *sb)
 357 {
 358         struct superblock_security_struct *sbsec = sb->s_security;
 359         struct dentry *root = sb->s_root;
 360         struct inode *root_inode = root->d_inode;
 361         int rc = 0;
 362
 363         if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
 364                 /* Make sure that the xattr handler exists and that no
 365                    error other than -ENODATA is returned by getxattr on
 366                    the root directory.  -ENODATA is ok, as this may be
 367                    the first boot of the SELinux kernel before we have
 368                    assigned xattr values to the filesystem. */
 369                 if (!root_inode->i_op->getxattr) {
 370                         printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
 371                                "xattr support\n", sb->s_id, sb->s_type->name);
 372                         rc = -EOPNOTSUPP;
 373                         goto out;
 374                 }
 375                 rc = root_inode->i_op->getxattr(root, XATTR_NAME_SELINUX, NULL, 0);
 376                 if (rc < 0 && rc != -ENODATA) {
 377                         if (rc == -EOPNOTSUPP)
 378                                 printk(KERN_WARNING "SELinux: (dev %s, type "
 379                                        "%s) has no security xattr handler\n",
 380                                        sb->s_id, sb->s_type->name);
 381                         else
 382                                 printk(KERN_WARNING "SELinux: (dev %s, type "
 383                                        "%s) getxattr errno %d\n", sb->s_id,
 384                                        sb->s_type->name, -rc);
 385                         goto out;
 386                 }
 387         }
 388
 389         sbsec->flags |= (SE_SBINITIALIZED | SE_SBLABELSUPP);
 390
 391         if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
 392                 printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
 393                        sb->s_id, sb->s_type->name);
 394         else
 395                 printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
 396                        sb->s_id, sb->s_type->name,
 397                        labeling_behaviors[sbsec->behavior-1]);
 398
 399         if (sbsec->behavior == SECURITY_FS_USE_GENFS ||
 400             sbsec->behavior == SECURITY_FS_USE_MNTPOINT ||
 401             sbsec->behavior == SECURITY_FS_USE_NONE ||
 402             sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
 403                 sbsec->flags &= ~SE_SBLABELSUPP;
 404
 405         /* Special handling for sysfs. Is genfs but also has setxattr handler*/
 406         if (strncmp(sb->s_type->name, "sysfs", sizeof("sysfs")) == 0)
 407                 sbsec->flags |= SE_SBLABELSUPP;
 408
 409         /* Initialize the root inode. */
 410         rc = inode_doinit_with_dentry(root_inode, root);
 411
 412         /* Initialize any other inodes associated with the superblock, e.g.
 413            inodes created prior to initial policy load or inodes created
 414            during get_sb by a pseudo filesystem that directly
 415            populates itself. */
 416         spin_lock(&sbsec->isec_lock);
 417 next_inode:
 418         if (!list_empty(&sbsec->isec_head)) {
 419                 struct inode_security_struct *isec =
 420                                 list_entry(sbsec->isec_head.next,
 421                                            struct inode_security_struct, list);
 422                 struct inode *inode = isec->inode;
 423                 spin_unlock(&sbsec->isec_lock);
 424                 inode = igrab(inode);
 425                 if (inode) {
 426                         if (!IS_PRIVATE(inode))
 427                                 inode_doinit(inode);
 428                         iput(inode);
 429                 }
 430                 spin_lock(&sbsec->isec_lock);
 431                 list_del_init(&isec->list);
 432                 goto next_inode;
 433         }
 434         spin_unlock(&sbsec->isec_lock);
 435 out:
 436         return rc;
 437 }
 438
 439 /*
 440  * This function should allow an FS to ask what it's mount security
 441  * options were so it can use those later for submounts, displaying
 442  * mount options, or whatever.
 443  */
 444 static int selinux_get_mnt_opts(const struct super_block *sb,
 445                                 struct security_mnt_opts *opts)
 446 {
 447         int rc = 0, i;
 448         struct superblock_security_struct *sbsec = sb->s_security;
 449         char *context = NULL;
 450         u32 len;
 451         char tmp;
 452
 453         security_init_mnt_opts(opts);
 454
 455         if (!(sbsec->flags & SE_SBINITIALIZED))
 456                 return -EINVAL;
 457
 458         if (!ss_initialized)
 459                 return -EINVAL;
 460
 461         tmp = sbsec->flags & SE_MNTMASK;
 462         /* count the number of mount options for this sb */
 463         for (i = 0; i < 8; i++) {
 464                 if (tmp & 0x01)
 465                         opts->num_mnt_opts++;
 466                 tmp >>= 1;
 467         }
 468         /* Check if the Label support flag is set */
 469         if (sbsec->flags & SE_SBLABELSUPP)
 470                 opts->num_mnt_opts++;
 471
 472         opts->mnt_opts = kcalloc(opts->num_mnt_opts, sizeof(char *), GFP_ATOMIC);
 473         if (!opts->mnt_opts) {
 474                 rc = -ENOMEM;
 475                 goto out_free;
 476         }
 477
 478         opts->mnt_opts_flags = kcalloc(opts->num_mnt_opts, sizeof(int), GFP_ATOMIC);
 479         if (!opts->mnt_opts_flags) {
 480                 rc = -ENOMEM;
 481                 goto out_free;
 482         }
 483
 484         i = 0;
 485         if (sbsec->flags & FSCONTEXT_MNT) {
 486                 rc = security_sid_to_context(sbsec->sid, &context, &len);
 487                 if (rc)
 488                         goto out_free;
 489                 opts->mnt_opts[i] = context;
 490                 opts->mnt_opts_flags[i++] = FSCONTEXT_MNT;
 491         }
 492         if (sbsec->flags & CONTEXT_MNT) {
 493                 rc = security_sid_to_context(sbsec->mntpoint_sid, &context, &len);
 494                 if (rc)
 495                         goto out_free;
 496                 opts->mnt_opts[i] = context;
 497                 opts->mnt_opts_flags[i++] = CONTEXT_MNT;
 498         }
 499         if (sbsec->flags & DEFCONTEXT_MNT) {
 500                 rc = security_sid_to_context(sbsec->def_sid, &context, &len);
 501                 if (rc)
 502                         goto out_free;
 503                 opts->mnt_opts[i] = context;
 504                 opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT;
 505         }
 506         if (sbsec->flags & ROOTCONTEXT_MNT) {
 507                 struct inode *root = sbsec->sb->s_root->d_inode;
 508                 struct inode_security_struct *isec = root->i_security;
 509
 510                 rc = security_sid_to_context(isec->sid, &context, &len);
 511                 if (rc)
 512                         goto out_free;
 513                 opts->mnt_opts[i] = context;
 514                 opts->mnt_opts_flags[i++] = ROOTCONTEXT_MNT;
 515         }
 516         if (sbsec->flags & SE_SBLABELSUPP) {
 517                 opts->mnt_opts[i] = NULL;
 518                 opts->mnt_opts_flags[i++] = SE_SBLABELSUPP;
 519         }
 520
 521         BUG_ON(i != opts->num_mnt_opts);
 522
 523         return 0;
 524
 525 out_free:
 526         security_free_mnt_opts(opts);
 527         return rc;
 528 }
 529
 530 static int bad_option(struct superblock_security_struct *sbsec, char flag,
 531                       u32 old_sid, u32 new_sid)
 532 {
 533         char mnt_flags = sbsec->flags & SE_MNTMASK;
 534
 535         /* check if the old mount command had the same options */
 536         if (sbsec->flags & SE_SBINITIALIZED)
 537                 if (!(sbsec->flags & flag) ||
 538                     (old_sid != new_sid))
 539                         return 1;
 540
 541         /* check if we were passed the same options twice,
 542          * aka someone passed context=a,context=b
 543          */
 544         if (!(sbsec->flags & SE_SBINITIALIZED))
 545                 if (mnt_flags & flag)
 546                         return 1;
 547         return 0;
 548 }
 549
 550 /*
 551  * Allow filesystems with binary mount data to explicitly set mount point
 552  * labeling information.
 553  */
 554 static int selinux_set_mnt_opts(struct super_block *sb,
 555                                 struct security_mnt_opts *opts)
 556 {
 557         const struct cred *cred = current_cred();
 558         int rc = 0, i;
 559         struct superblock_security_struct *sbsec = sb->s_security;
 560         const char *name = sb->s_type->name;
 561         struct inode *inode = sbsec->sb->s_root->d_inode;
 562         struct inode_security_struct *root_isec = inode->i_security;
 563         u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
 564         u32 defcontext_sid = 0;
 565         char **mount_options = opts->mnt_opts;
 566         int *flags = opts->mnt_opts_flags;
 567         int num_opts = opts->num_mnt_opts;
 568
 569         mutex_lock(&sbsec->lock);
 570
 571         if (!ss_initialized) {
 572                 if (!num_opts) {
 573                         /* Defer initialization until selinux_complete_init,
 574                            after the initial policy is loaded and the security
 575                            server is ready to handle calls. */
 576                         goto out;
 577                 }
 578                 rc = -EINVAL;
 579                 printk(KERN_WARNING "SELinux: Unable to set superblock options "
 580                         "before the security server is initialized\n");
 581                 goto out;
 582         }
 583
 584         /*
 585          * Binary mount data FS will come through this function twice.  Once
 586          * from an explicit call and once from the generic calls from the vfs.
 587          * Since the generic VFS calls will not contain any security mount data
 588          * we need to skip the double mount verification.
 589          *
 590          * This does open a hole in which we will not notice if the first
 591          * mount using this sb set explict options and a second mount using
 592          * this sb does not set any security options.  (The first options
 593          * will be used for both mounts)
 594          */
 595         if ((sbsec->flags & SE_SBINITIALIZED) && (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
 596             && (num_opts == 0))
 597                 goto out;
 598
 599         /*
 600          * parse the mount options, check if they are valid sids.
 601          * also check if someone is trying to mount the same sb more
 602          * than once with different security options.
 603          */
 604         for (i = 0; i < num_opts; i++) {
 605                 u32 sid;
 606
 607                 if (flags[i] == SE_SBLABELSUPP)
 608                         continue;
 609                 rc = security_context_to_sid(mount_options[i],
 610                                              strlen(mount_options[i]), &sid);
 611                 if (rc) {
 612                         printk(KERN_WARNING "SELinux: security_context_to_sid"
 613                                "(%s) failed for (dev %s, type %s) errno=%d\n",
 614                                mount_options[i], sb->s_id, name, rc);
 615                         goto out;
 616                 }
 617                 switch (flags[i]) {
 618                 case FSCONTEXT_MNT:
 619                         fscontext_sid = sid;
 620
 621                         if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid,
 622                                         fscontext_sid))
 623                                 goto out_double_mount;
 624
 625                         sbsec->flags |= FSCONTEXT_MNT;
 626                         break;
 627                 case CONTEXT_MNT:
 628                         context_sid = sid;
 629
 630                         if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid,
 631                                         context_sid))
 632                                 goto out_double_mount;
 633
 634                         sbsec->flags |= CONTEXT_MNT;
 635                         break;
 636                 case ROOTCONTEXT_MNT:
 637                         rootcontext_sid = sid;
 638
 639                         if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid,
 640                                         rootcontext_sid))
 641                                 goto out_double_mount;
 642
 643                         sbsec->flags |= ROOTCONTEXT_MNT;
 644
 645                         break;
 646                 case DEFCONTEXT_MNT:
 647                         defcontext_sid = sid;
 648
 649                         if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid,
 650                                         defcontext_sid))
 651                                 goto out_double_mount;
 652
 653                         sbsec->flags |= DEFCONTEXT_MNT;
 654
 655                         break;
 656                 default:
 657                         rc = -EINVAL;
 658                         goto out;
 659                 }
 660         }
 661
 662         if (sbsec->flags & SE_SBINITIALIZED) {
 663                 /* previously mounted with options, but not on this attempt? */
 664                 if ((sbsec->flags & SE_MNTMASK) && !num_opts)
 665                         goto out_double_mount;
 666                 rc = 0;
 667                 goto out;
 668         }
 669
 670         if (strcmp(sb->s_type->name, "proc") == 0)
 671                 sbsec->flags |= SE_SBPROC;
 672
 673         /* Determine the labeling behavior to use for this filesystem type. */
 674         rc = security_fs_use((sbsec->flags & SE_SBPROC) ? "proc" : sb->s_type->name, &sbsec->behavior, &sbsec->sid);
 675         if (rc) {
 676                 printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n",
 677                        __func__, sb->s_type->name, rc);
 678                 goto out;
 679         }
 680
 681         /* sets the context of the superblock for the fs being mounted. */
 682         if (fscontext_sid) {
 683                 rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, cred);
 684                 if (rc)
 685                         goto out;
 686
 687                 sbsec->sid = fscontext_sid;
 688         }
 689
 690         /*
 691          * Switch to using mount point labeling behavior.
 692          * sets the label used on all file below the mountpoint, and will set
 693          * the superblock context if not already set.
 694          */
 695         if (context_sid) {
 696                 if (!fscontext_sid) {
 697                         rc = may_context_mount_sb_relabel(context_sid, sbsec,
 698                                                           cred);
 699                         if (rc)
 700                                 goto out;
 701                         sbsec->sid = context_sid;
 702                 } else {
 703                         rc = may_context_mount_inode_relabel(context_sid, sbsec,
 704                                                              cred);
 705                         if (rc)
 706                                 goto out;
 707                 }
 708                 if (!rootcontext_sid)
 709                         rootcontext_sid = context_sid;
 710
 711                 sbsec->mntpoint_sid = context_sid;
 712                 sbsec->behavior = SECURITY_FS_USE_MNTPOINT;
 713         }
 714
 715         if (rootcontext_sid) {
 716                 rc = may_context_mount_inode_relabel(rootcontext_sid, sbsec,
 717                                                      cred);
 718                 if (rc)
 719                         goto out;
 720
 721                 root_isec->sid = rootcontext_sid;
 722                 root_isec->initialized = 1;
 723         }
 724
 725         if (defcontext_sid) {
 726                 if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
 727                         rc = -EINVAL;
 728                         printk(KERN_WARNING "SELinux: defcontext option is "
 729                                "invalid for this filesystem type\n");
 730                         goto out;
 731                 }
 732
 733                 if (defcontext_sid != sbsec->def_sid) {
 734                         rc = may_context_mount_inode_relabel(defcontext_sid,
 735                                                              sbsec, cred);
 736                         if (rc)
 737                                 goto out;
 738                 }
 739
 740                 sbsec->def_sid = defcontext_sid;
 741         }
 742
 743         rc = sb_finish_set_opts(sb);
 744 out:
 745         mutex_unlock(&sbsec->lock);
 746         return rc;
 747 out_double_mount:
 748         rc = -EINVAL;
 749         printk(KERN_WARNING "SELinux: mount invalid.  Same superblock, different "
 750                "security settings for (dev %s, type %s)\n", sb->s_id, name);
 751         goto out;
 752 }
 753
 754 static void selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
 755                                         struct super_block *newsb)
 756 {
 757         const struct superblock_security_struct *oldsbsec = oldsb->s_security;
 758         struct superblock_security_struct *newsbsec = newsb->s_security;
 759
 760         int set_fscontext =     (oldsbsec->flags & FSCONTEXT_MNT);
 761         int set_context =       (oldsbsec->flags & CONTEXT_MNT);
 762         int set_rootcontext =   (oldsbsec->flags & ROOTCONTEXT_MNT);
 763
 764         /*
 765          * if the parent was able to be mounted it clearly had no special lsm
 766          * mount options.  thus we can safely deal with this superblock later
 767          */
 768         if (!ss_initialized)
 769                 return;
 770
 771         /* how can we clone if the old one wasn't set up?? */
 772         BUG_ON(!(oldsbsec->flags & SE_SBINITIALIZED));
 773
 774         /* if fs is reusing a sb, just let its options stand... */
 775         if (newsbsec->flags & SE_SBINITIALIZED)
 776                 return;
 777
 778         mutex_lock(&newsbsec->lock);
 779
 780         newsbsec->flags = oldsbsec->flags;
 781
 782         newsbsec->sid = oldsbsec->sid;
 783         newsbsec->def_sid = oldsbsec->def_sid;
 784         newsbsec->behavior = oldsbsec->behavior;
 785
 786         if (set_context) {
 787                 u32 sid = oldsbsec->mntpoint_sid;
 788
 789                 if (!set_fscontext)
 790                         newsbsec->sid = sid;
 791                 if (!set_rootcontext) {
 792                         struct inode *newinode = newsb->s_root->d_inode;
 793                         struct inode_security_struct *newisec = newinode->i_security;
 794                         newisec->sid = sid;
 795                 }
 796                 newsbsec->mntpoint_sid = sid;
 797         }
 798         if (set_rootcontext) {
 799                 const struct inode *oldinode = oldsb->s_root->d_inode;
 800                 const struct inode_security_struct *oldisec = oldinode->i_security;
 801                 struct inode *newinode = newsb->s_root->d_inode;
 802                 struct inode_security_struct *newisec = newinode->i_security;
 803
 804                 newisec->sid = oldisec->sid;
 805         }
 806
 807         sb_finish_set_opts(newsb);
 808         mutex_unlock(&newsbsec->lock);
 809 }
 810
 811 static int selinux_parse_opts_str(char *options,
 812                                   struct security_mnt_opts *opts)
 813 {
 814         char *p;
 815         char *context = NULL, *defcontext = NULL;
 816         char *fscontext = NULL, *rootcontext = NULL;
 817         int rc, num_mnt_opts = 0;
 818
 819         opts->num_mnt_opts = 0;
 820
 821         /* Standard string-based options. */
 822         while ((p = strsep(&options, "|")) != NULL) {
 823                 int token;
 824                 substring_t args[MAX_OPT_ARGS];
 825
 826                 if (!*p)
 827                         continue;
 828
 829                 token = match_token(p, tokens, args);
 830
 831                 switch (token) {
 832                 case Opt_context:
 833                         if (context || defcontext) {
 834                                 rc = -EINVAL;
 835                                 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
 836                                 goto out_err;
 837                         }
 838                         context = match_strdup(&args[0]);
 839                         if (!context) {
 840                                 rc = -ENOMEM;
 841                                 goto out_err;
 842                         }
 843                         break;
 844
 845                 case Opt_fscontext:
 846                         if (fscontext) {
 847                                 rc = -EINVAL;
 848                                 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
 849                                 goto out_err;
 850                         }
 851                         fscontext = match_strdup(&args[0]);
 852                         if (!fscontext) {
 853                                 rc = -ENOMEM;
 854                                 goto out_err;
 855                         }
 856                         break;
 857
 858                 case Opt_rootcontext:
 859                         if (rootcontext) {
 860                                 rc = -EINVAL;
 861                                 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
 862                                 goto out_err;
 863                         }
 864                         rootcontext = match_strdup(&args[0]);
 865                         if (!rootcontext) {
 866                                 rc = -ENOMEM;
 867                                 goto out_err;
 868                         }
 869                         break;
 870
 871                 case Opt_defcontext:
 872                         if (context || defcontext) {
 873                                 rc = -EINVAL;
 874                                 printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
 875                                 goto out_err;
 876                         }
 877                         defcontext = match_strdup(&args[0]);
 878                         if (!defcontext) {
 879                                 rc = -ENOMEM;
 880                                 goto out_err;
 881                         }
 882                         break;
 883                 case Opt_labelsupport:
 884                         break;
 885                 default:
 886                         rc = -EINVAL;
 887                         printk(KERN_WARNING "SELinux:  unknown mount option\n");
 888                         goto out_err;
 889
 890                 }
 891         }
 892
 893         rc = -ENOMEM;
 894         opts->mnt_opts = kcalloc(NUM_SEL_MNT_OPTS, sizeof(char *), GFP_ATOMIC);
 895         if (!opts->mnt_opts)
 896                 goto out_err;
 897
 898         opts->mnt_opts_flags = kcalloc(NUM_SEL_MNT_OPTS, sizeof(int), GFP_ATOMIC);
 899         if (!opts->mnt_opts_flags) {
 900                 kfree(opts->mnt_opts);
 901                 goto out_err;
 902         }
 903
 904         if (fscontext) {
 905                 opts->mnt_opts[num_mnt_opts] = fscontext;
 906                 opts->mnt_opts_flags[num_mnt_opts++] = FSCONTEXT_MNT;
 907         }
 908         if (context) {
 909                 opts->mnt_opts[num_mnt_opts] = context;
 910                 opts->mnt_opts_flags[num_mnt_opts++] = CONTEXT_MNT;
 911         }
 912         if (rootcontext) {
 913                 opts->mnt_opts[num_mnt_opts] = rootcontext;
 914                 opts->mnt_opts_flags[num_mnt_opts++] = ROOTCONTEXT_MNT;
 915         }
 916         if (defcontext) {
 917                 opts->mnt_opts[num_mnt_opts] = defcontext;
 918                 opts->mnt_opts_flags[num_mnt_opts++] = DEFCONTEXT_MNT;
 919         }
 920
 921         opts->num_mnt_opts = num_mnt_opts;
 922         return 0;
 923
 924 out_err:
 925         kfree(context);
 926         kfree(defcontext);
 927         kfree(fscontext);
 928         kfree(rootcontext);
 929         return rc;
 930 }
 931 /*
 932  * string mount options parsing and call set the sbsec
 933  */
 934 static int superblock_doinit(struct super_block *sb, void *data)
 935 {
 936         int rc = 0;
 937         char *options = data;
 938         struct security_mnt_opts opts;
 939
 940         security_init_mnt_opts(&opts);
 941
 942         if (!data)
 943                 goto out;
 944
 945         BUG_ON(sb->s_type->fs_flags & FS_BINARY_MOUNTDATA);
 946
 947         rc = selinux_parse_opts_str(options, &opts);
 948         if (rc)
 949                 goto out_err;
 950
 951 out:
 952         rc = selinux_set_mnt_opts(sb, &opts);
 953
 954 out_err:
 955         security_free_mnt_opts(&opts);
 956         return rc;
 957 }
 958
 959 static void selinux_write_opts(struct seq_file *m,
 960                                struct security_mnt_opts *opts)
 961 {
 962         int i;
 963         char *prefix;
 964
 965         for (i = 0; i < opts->num_mnt_opts; i++) {
 966                 char *has_comma;
 967
 968                 if (opts->mnt_opts[i])
 969                         has_comma = strchr(opts->mnt_opts[i], ',');
 970                 else
 971                         has_comma = NULL;
 972
 973                 switch (opts->mnt_opts_flags[i]) {
 974                 case CONTEXT_MNT:
 975                         prefix = CONTEXT_STR;
 976                         break;
 977                 case FSCONTEXT_MNT:
 978                         prefix = FSCONTEXT_STR;
 979                         break;
 980                 case ROOTCONTEXT_MNT:
 981                         prefix = ROOTCONTEXT_STR;
 982                         break;
 983                 case DEFCONTEXT_MNT:
 984                         prefix = DEFCONTEXT_STR;
 985                         break;
 986                 case SE_SBLABELSUPP:
 987                         seq_putc(m, ',');
 988                         seq_puts(m, LABELSUPP_STR);
 989                         continue;
 990                 default:
 991                         BUG();
 992                         return;
 993                 };
 994                 /* we need a comma before each option */
 995                 seq_putc(m, ',');
 996                 seq_puts(m, prefix);
 997                 if (has_comma)
 998                         seq_putc(m, '\"');
 999                 seq_puts(m, opts->mnt_opts[i]);
1000                 if (has_comma)
1001                         seq_putc(m, '\"');
1002         }
1003 }
1004
1005 static int selinux_sb_show_options(struct seq_file *m, struct super_block *sb)
1006 {
1007         struct security_mnt_opts opts;
1008         int rc;
1009
1010         rc = selinux_get_mnt_opts(sb, &opts);
1011         if (rc) {
1012                 /* before policy load we may get EINVAL, don't show anything */
1013                 if (rc == -EINVAL)
1014                         rc = 0;
1015                 return rc;
1016         }
1017
1018         selinux_write_opts(m, &opts);
1019
1020         security_free_mnt_opts(&opts);
1021
1022         return rc;
1023 }
1024
1025 static inline u16 inode_mode_to_security_class(umode_t mode)
1026 {
1027         switch (mode & S_IFMT) {
1028         case S_IFSOCK:
1029                 return SECCLASS_SOCK_FILE;
1030         case S_IFLNK:
1031                 return SECCLASS_LNK_FILE;
1032         case S_IFREG:
1033                 return SECCLASS_FILE;
1034         case S_IFBLK:
1035                 return SECCLASS_BLK_FILE;
1036         case S_IFDIR:
1037                 return SECCLASS_DIR;
1038         case S_IFCHR:
1039                 return SECCLASS_CHR_FILE;
1040         case S_IFIFO:
1041                 return SECCLASS_FIFO_FILE;
1042
1043         }
1044
1045         return SECCLASS_FILE;
1046 }
1047
1048 static inline int default_protocol_stream(int protocol)
1049 {
1050         return (protocol == IPPROTO_IP || protocol == IPPROTO_TCP);
1051 }
1052
1053 static inline int default_protocol_dgram(int protocol)
1054 {
1055         return (protocol == IPPROTO_IP || protocol == IPPROTO_UDP);
1056 }
1057
1058 static inline u16 socket_type_to_security_class(int family, int type, int protocol)
1059 {
1060         switch (family) {
1061         case PF_UNIX:
1062                 switch (type) {
1063                 case SOCK_STREAM:
1064                 case SOCK_SEQPACKET:
1065                         return SECCLASS_UNIX_STREAM_SOCKET;
1066                 case SOCK_DGRAM:
1067                         return SECCLASS_UNIX_DGRAM_SOCKET;
1068                 }
1069                 break;
1070         case PF_INET:
1071         case PF_INET6:
1072                 switch (type) {
1073                 case SOCK_STREAM:
1074                         if (default_protocol_stream(protocol))
1075                                 return SECCLASS_TCP_SOCKET;
1076                         else
1077                                 return SECCLASS_RAWIP_SOCKET;
1078                 case SOCK_DGRAM:
1079                         if (default_protocol_dgram(protocol))
1080                                 return SECCLASS_UDP_SOCKET;
1081                         else
1082                                 return SECCLASS_RAWIP_SOCKET;
1083                 case SOCK_DCCP:
1084                         return SECCLASS_DCCP_SOCKET;
1085                 default:
1086                         return SECCLASS_RAWIP_SOCKET;
1087                 }
1088                 break;
1089         case PF_NETLINK:
1090                 switch (protocol) {
1091                 case NETLINK_ROUTE:
1092                         return SECCLASS_NETLINK_ROUTE_SOCKET;
1093                 case NETLINK_FIREWALL:
1094                         return SECCLASS_NETLINK_FIREWALL_SOCKET;
1095                 case NETLINK_INET_DIAG:
1096                         return SECCLASS_NETLINK_TCPDIAG_SOCKET;
1097                 case NETLINK_NFLOG:
1098                         return SECCLASS_NETLINK_NFLOG_SOCKET;
1099                 case NETLINK_XFRM:
1100                         return SECCLASS_NETLINK_XFRM_SOCKET;
1101                 case NETLINK_SELINUX:
1102                         return SECCLASS_NETLINK_SELINUX_SOCKET;
1103                 case NETLINK_AUDIT:
1104                         return SECCLASS_NETLINK_AUDIT_SOCKET;
1105                 case NETLINK_IP6_FW:
1106                         return SECCLASS_NETLINK_IP6FW_SOCKET;
1107                 case NETLINK_DNRTMSG:
1108                         return SECCLASS_NETLINK_DNRT_SOCKET;
1109                 case NETLINK_KOBJECT_UEVENT:
1110                         return SECCLASS_NETLINK_KOBJECT_UEVENT_SOCKET;
1111                 default:
1112                         return SECCLASS_NETLINK_SOCKET;
1113                 }
1114         case PF_PACKET:
1115                 return SECCLASS_PACKET_SOCKET;
1116         case PF_KEY:
1117                 return SECCLASS_KEY_SOCKET;
1118         case PF_APPLETALK:
1119                 return SECCLASS_APPLETALK_SOCKET;
1120         }
1121
1122         return SECCLASS_SOCKET;
1123 }
1124
1125 #ifdef CONFIG_PROC_FS
1126 static int selinux_proc_get_sid(struct dentry *dentry,
1127                                 u16 tclass,
1128                                 u32 *sid)
1129 {
1130         int rc;
1131         char *buffer, *path;
1132
1133         buffer = (char *)__get_free_page(GFP_KERNEL);
1134         if (!buffer)
1135                 return -ENOMEM;
1136
1137         path = dentry_path_raw(dentry, buffer, PAGE_SIZE);
1138         if (IS_ERR(path))
1139                 rc = PTR_ERR(path);
1140         else {
1141                 /* each process gets a /proc/PID/ entry. Strip off the
1142                  * PID part to get a valid selinux labeling.
1143                  * e.g. /proc/1/net/rpc/nfs -> /net/rpc/nfs */
1144                 while (path[1] >= '0' && path[1] <= '9') {
1145                         path[1] = '/';
1146                         path++;
1147                 }
1148                 rc = security_genfs_sid("proc", path, tclass, sid);
1149         }
1150         free_page((unsigned long)buffer);
1151         return rc;
1152 }
1153 #else
1154 static int selinux_proc_get_sid(struct dentry *dentry,
1155                                 u16 tclass,
1156                                 u32 *sid)
1157 {
1158         return -EINVAL;
1159 }
1160 #endif
1161
1162 /* The inode's security attributes must be initialized before first use. */
1163 static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry)
1164 {
1165         struct superblock_security_struct *sbsec = NULL;
1166         struct inode_security_struct *isec = inode->i_security;
1167         u32 sid;
1168         struct dentry *dentry;
1169 #define INITCONTEXTLEN 255
1170         char *context = NULL;
1171         unsigned len = 0;
1172         int rc = 0;
1173
1174         if (isec->initialized)
1175                 goto out;
1176
1177         mutex_lock(&isec->lock);
1178         if (isec->initialized)
1179                 goto out_unlock;
1180
1181         sbsec = inode->i_sb->s_security;
1182         if (!(sbsec->flags & SE_SBINITIALIZED)) {
1183                 /* Defer initialization until selinux_complete_init,
1184                    after the initial policy is loaded and the security
1185                    server is ready to handle calls. */
1186                 spin_lock(&sbsec->isec_lock);
1187                 if (list_empty(&isec->list))
1188                         list_add(&isec->list, &sbsec->isec_head);
1189                 spin_unlock(&sbsec->isec_lock);
1190                 goto out_unlock;
1191         }
1192
1193         switch (sbsec->behavior) {
1194         case SECURITY_FS_USE_XATTR:
1195                 if (!inode->i_op->getxattr) {
1196                         isec->sid = sbsec->def_sid;
1197                         break;
1198                 }
1199
1200                 /* Need a dentry, since the xattr API requires one.
1201                    Life would be simpler if we could just pass the inode. */
1202                 if (opt_dentry) {
1203                         /* Called from d_instantiate or d_splice_alias. */
1204                         dentry = dget(opt_dentry);
1205                 } else {
1206                         /* Called from selinux_complete_init, try to find a dentry. */
1207                         dentry = d_find_alias(inode);
1208                 }
1209                 if (!dentry) {
1210                         /*
1211                          * this is can be hit on boot when a file is accessed
1212                          * before the policy is loaded.  When we load policy we
1213                          * may find inodes that have no dentry on the
1214                          * sbsec->isec_head list.  No reason to complain as these
1215                          * will get fixed up the next time we go through
1216                          * inode_doinit with a dentry, before these inodes could
1217                          * be used again by userspace.
1218                          */
1219                         goto out_unlock;
1220                 }
1221
1222                 len = INITCONTEXTLEN;
1223                 context = kmalloc(len+1, GFP_NOFS);
1224                 if (!context) {
1225                         rc = -ENOMEM;
1226                         dput(dentry);
1227                         goto out_unlock;
1228                 }
1229                 context[len] = '\0';
1230                 rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1231                                            context, len);
1232                 if (rc == -ERANGE) {
1233                         kfree(context);
1234
1235                         /* Need a larger buffer.  Query for the right size. */
1236                         rc = inode->i_op->getxattr(dentry, XATTR_NAME_SELINUX,
1237                                                    NULL, 0);
1238                         if (rc < 0) {
1239                                 dput(dentry);
1240                                 goto out_unlock;
1241                         }
1242                         len = rc;
1243                         context = kmalloc(len+1, GFP_NOFS);
1244                         if (!context) {
1245                                 rc = -ENOMEM;
1246                                 dput(dentry);
1247                                 goto out_unlock;
1248                         }
1249                         context[len] = '\0';
1250                         rc = inode->i_op->getxattr(dentry,
1251                                                    XATTR_NAME_SELINUX,
1252                                                    context, len);
1253                 }
1254                 dput(dentry);
1255                 if (rc < 0) {
1256                         if (rc != -ENODATA) {
1257                                 printk(KERN_WARNING "SELinux: %s:  getxattr returned "
1258                                        "%d for dev=%s ino=%ld\n", __func__,
1259                                        -rc, inode->i_sb->s_id, inode->i_ino);
1260                                 kfree(context);
1261                                 goto out_unlock;
1262                         }
1263                         /* Map ENODATA to the default file SID */
1264                         sid = sbsec->def_sid;
1265                         rc = 0;
1266                 } else {
1267                         rc = security_context_to_sid_default(context, rc, &sid,
1268                                                              sbsec->def_sid,
1269                                                              GFP_NOFS);
1270                         if (rc) {
1271                                 char *dev = inode->i_sb->s_id;
1272                                 unsigned long ino = inode->i_ino;
1273
1274                                 if (rc == -EINVAL) {
1275                                         if (printk_ratelimit())
1276                                                 printk(KERN_NOTICE "SELinux: inode=%lu on dev=%s was found to have an invalid "
1277                                                         "context=%s.  This indicates you may need to relabel the inode or the "
1278                                                         "filesystem in question.\n", ino, dev, context);
1279                                 } else {
1280                                         printk(KERN_WARNING "SELinux: %s:  context_to_sid(%s) "
1281                                                "returned %d for dev=%s ino=%ld\n",
1282                                                __func__, context, -rc, dev, ino);
1283                                 }
1284                                 kfree(context);
1285                                 /* Leave with the unlabeled SID */
1286                                 rc = 0;
1287                                 break;
1288                         }
1289                 }
1290                 kfree(context);
1291                 isec->sid = sid;
1292                 break;
1293         case SECURITY_FS_USE_TASK:
1294                 isec->sid = isec->task_sid;
1295                 break;
1296         case SECURITY_FS_USE_TRANS:
1297                 /* Default to the fs SID. */
1298                 isec->sid = sbsec->sid;
1299
1300                 /* Try to obtain a transition SID. */
1301                 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1302                 rc = security_transition_sid(isec->task_sid, sbsec->sid,
1303                                              isec->sclass, NULL, &sid);
1304                 if (rc)
1305                         goto out_unlock;
1306                 isec->sid = sid;
1307                 break;
1308         case SECURITY_FS_USE_MNTPOINT:
1309                 isec->sid = sbsec->mntpoint_sid;
1310                 break;
1311         default:
1312                 /* Default to the fs superblock SID. */
1313                 isec->sid = sbsec->sid;
1314
1315                 if ((sbsec->flags & SE_SBPROC) && !S_ISLNK(inode->i_mode)) {
1316                         if (opt_dentry) {
1317                                 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1318                                 rc = selinux_proc_get_sid(opt_dentry,
1319                                                           isec->sclass,
1320                                                           &sid);
1321                                 if (rc)
1322                                         goto out_unlock;
1323                                 isec->sid = sid;
1324                         }
1325                 }
1326                 break;
1327         }
1328
1329         isec->initialized = 1;
1330
1331 out_unlock:
1332         mutex_unlock(&isec->lock);
1333 out:
1334         if (isec->sclass == SECCLASS_FILE)
1335                 isec->sclass = inode_mode_to_security_class(inode->i_mode);
1336         return rc;
1337 }
1338
1339 /* Convert a Linux signal to an access vector. */
1340 static inline u32 signal_to_av(int sig)
1341 {
1342         u32 perm = 0;
1343
1344         switch (sig) {
1345         case SIGCHLD:
1346                 /* Commonly granted from child to parent. */
1347                 perm = PROCESS__SIGCHLD;
1348                 break;
1349         case SIGKILL:
1350                 /* Cannot be caught or ignored */
1351                 perm = PROCESS__SIGKILL;
1352                 break;
1353         case SIGSTOP:
1354                 /* Cannot be caught or ignored */
1355                 perm = PROCESS__SIGSTOP;
1356                 break;
1357         default:
1358                 /* All other signals. */
1359                 perm = PROCESS__SIGNAL;
1360                 break;
1361         }
1362
1363         return perm;
1364 }
1365
1366 /*
1367  * Check permission between a pair of credentials
1368  * fork check, ptrace check, etc.
1369  */
1370 static int cred_has_perm(const struct cred *actor,
1371                          const struct cred *target,
1372                          u32 perms)
1373 {
1374         u32 asid = cred_sid(actor), tsid = cred_sid(target);
1375
1376         return avc_has_perm(asid, tsid, SECCLASS_PROCESS, perms, NULL);
1377 }
1378
1379 /*
1380  * Check permission between a pair of tasks, e.g. signal checks,
1381  * fork check, ptrace check, etc.
1382  * tsk1 is the actor and tsk2 is the target
1383  * - this uses the default subjective creds of tsk1
1384  */
1385 static int task_has_perm(const struct task_struct *tsk1,
1386                          const struct task_struct *tsk2,
1387                          u32 perms)
1388 {
1389         const struct task_security_struct *__tsec1, *__tsec2;
1390         u32 sid1, sid2;
1391
1392         rcu_read_lock();
1393         __tsec1 = __task_cred(tsk1)->security;  sid1 = __tsec1->sid;
1394         __tsec2 = __task_cred(tsk2)->security;  sid2 = __tsec2->sid;
1395         rcu_read_unlock();
1396         return avc_has_perm(sid1, sid2, SECCLASS_PROCESS, perms, NULL);
1397 }
1398
1399 /*
1400  * Check permission between current and another task, e.g. signal checks,
1401  * fork check, ptrace check, etc.
1402  * current is the actor and tsk2 is the target
1403  * - this uses current's subjective creds
1404  */
1405 static int current_has_perm(const struct task_struct *tsk,
1406                             u32 perms)
1407 {
1408         u32 sid, tsid;
1409
1410         sid = current_sid();
1411         tsid = task_sid(tsk);
1412         return avc_has_perm(sid, tsid, SECCLASS_PROCESS, perms, NULL);
1413 }
1414
1415 #if CAP_LAST_CAP > 63
1416 #error Fix SELinux to handle capabilities > 63.
1417 #endif
1418
1419 /* Check whether a task is allowed to use a capability. */
1420 static int task_has_capability(struct task_struct *tsk,
1421                                const struct cred *cred,
1422                                int cap, int audit)
1423 {
1424         struct common_audit_data ad;
1425         struct av_decision avd;
1426         u16 sclass;
1427         u32 sid = cred_sid(cred);
1428         u32 av = CAP_TO_MASK(cap);
1429         int rc;
1430
1431         COMMON_AUDIT_DATA_INIT(&ad, CAP);
1432         ad.tsk = tsk;
1433         ad.u.cap = cap;
1434
1435         switch (CAP_TO_INDEX(cap)) {
1436         case 0:
1437                 sclass = SECCLASS_CAPABILITY;
1438                 break;
1439         case 1:
1440                 sclass = SECCLASS_CAPABILITY2;
1441                 break;
1442         default:
1443                 printk(KERN_ERR
1444                        "SELinux:  out of range capability %d\n", cap);
1445                 BUG();
1446                 return -EINVAL;
1447         }
1448
1449         rc = avc_has_perm_noaudit(sid, sid, sclass, av, 0, &avd);
1450         if (audit == SECURITY_CAP_AUDIT) {
1451                 int rc2 = avc_audit(sid, sid, sclass, av, &avd, rc, &ad, 0);
1452                 if (rc2)
1453                         return rc2;
1454         }
1455         return rc;
1456 }
1457
1458 /* Check whether a task is allowed to use a system operation. */
1459 static int task_has_system(struct task_struct *tsk,
1460                            u32 perms)
1461 {
1462         u32 sid = task_sid(tsk);
1463
1464         return avc_has_perm(sid, SECINITSID_KERNEL,
1465                             SECCLASS_SYSTEM, perms, NULL);
1466 }
1467
1468 /* Check whether a task has a particular permission to an inode.
1469    The 'adp' parameter is optional and allows other audit
1470    data to be passed (e.g. the dentry). */
1471 static int inode_has_perm(const struct cred *cred,
1472                           struct inode *inode,
1473                           u32 perms,
1474                           struct common_audit_data *adp,
1475                           unsigned flags)
1476 {
1477         struct inode_security_struct *isec;
1478         struct common_audit_data ad;
1479         u32 sid;
1480
1481         validate_creds(cred);
1482
1483         if (unlikely(IS_PRIVATE(inode)))
1484                 return 0;
1485
1486         sid = cred_sid(cred);
1487         isec = inode->i_security;
1488
1489         if (!adp) {
1490                 adp = &ad;
1491                 COMMON_AUDIT_DATA_INIT(&ad, INODE);
1492                 ad.u.inode = inode;
1493         }
1494
1495         return avc_has_perm_flags(sid, isec->sid, isec->sclass, perms, adp, flags);
1496 }
1497
1498 /* Same as inode_has_perm, but pass explicit audit data containing
1499    the dentry to help the auditing code to more easily generate the
1500    pathname if needed. */
1501 static inline int dentry_has_perm(const struct cred *cred,
1502                                   struct dentry *dentry,
1503                                   u32 av)
1504 {
1505         struct inode *inode = dentry->d_inode;
1506         struct common_audit_data ad;
1507
1508         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1509         ad.u.dentry = dentry;
1510         return inode_has_perm(cred, inode, av, &ad, 0);
1511 }
1512
1513 /* Same as inode_has_perm, but pass explicit audit data containing
1514    the path to help the auditing code to more easily generate the
1515    pathname if needed. */
1516 static inline int path_has_perm(const struct cred *cred,
1517                                 struct path *path,
1518                                 u32 av)
1519 {
1520         struct inode *inode = path->dentry->d_inode;
1521         struct common_audit_data ad;
1522
1523         COMMON_AUDIT_DATA_INIT(&ad, PATH);
1524         ad.u.path = *path;
1525         return inode_has_perm(cred, inode, av, &ad, 0);
1526 }
1527
1528 /* Check whether a task can use an open file descriptor to
1529    access an inode in a given way.  Check access to the
1530    descriptor itself, and then use dentry_has_perm to
1531    check a particular permission to the file.
1532    Access to the descriptor is implicitly granted if it
1533    has the same SID as the process.  If av is zero, then
1534    access to the file is not checked, e.g. for cases
1535    where only the descriptor is affected like seek. */
1536 static int file_has_perm(const struct cred *cred,
1537                          struct file *file,
1538                          u32 av)
1539 {
1540         struct file_security_struct *fsec = file->f_security;
1541         struct inode *inode = file->f_path.dentry->d_inode;
1542         struct common_audit_data ad;
1543         u32 sid = cred_sid(cred);
1544         int rc;
1545
1546         COMMON_AUDIT_DATA_INIT(&ad, PATH);
1547         ad.u.path = file->f_path;
1548
1549         if (sid != fsec->sid) {
1550                 rc = avc_has_perm(sid, fsec->sid,
1551                                   SECCLASS_FD,
1552                                   FD__USE,
1553                                   &ad);
1554                 if (rc)
1555                         goto out;
1556         }
1557
1558         /* av is zero if only checking access to the descriptor. */
1559         rc = 0;
1560         if (av)
1561                 rc = inode_has_perm(cred, inode, av, &ad, 0);
1562
1563 out:
1564         return rc;
1565 }
1566
1567 /* Check whether a task can create a file. */
1568 static int may_create(struct inode *dir,
1569                       struct dentry *dentry,
1570                       u16 tclass)
1571 {
1572         const struct task_security_struct *tsec = current_security();
1573         struct inode_security_struct *dsec;
1574         struct superblock_security_struct *sbsec;
1575         u32 sid, newsid;
1576         struct common_audit_data ad;
1577         int rc;
1578
1579         dsec = dir->i_security;
1580         sbsec = dir->i_sb->s_security;
1581
1582         sid = tsec->sid;
1583         newsid = tsec->create_sid;
1584
1585         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1586         ad.u.dentry = dentry;
1587
1588         rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR,
1589                           DIR__ADD_NAME | DIR__SEARCH,
1590                           &ad);
1591         if (rc)
1592                 return rc;
1593
1594         if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
1595                 rc = security_transition_sid(sid, dsec->sid, tclass,
1596                                              &dentry->d_name, &newsid);
1597                 if (rc)
1598                         return rc;
1599         }
1600
1601         rc = avc_has_perm(sid, newsid, tclass, FILE__CREATE, &ad);
1602         if (rc)
1603                 return rc;
1604
1605         return avc_has_perm(newsid, sbsec->sid,
1606                             SECCLASS_FILESYSTEM,
1607                             FILESYSTEM__ASSOCIATE, &ad);
1608 }
1609
1610 /* Check whether a task can create a key. */
1611 static int may_create_key(u32 ksid,
1612                           struct task_struct *ctx)
1613 {
1614         u32 sid = task_sid(ctx);
1615
1616         return avc_has_perm(sid, ksid, SECCLASS_KEY, KEY__CREATE, NULL);
1617 }
1618
1619 #define MAY_LINK        0
1620 #define MAY_UNLINK      1
1621 #define MAY_RMDIR       2
1622
1623 /* Check whether a task can link, unlink, or rmdir a file/directory. */
1624 static int may_link(struct inode *dir,
1625                     struct dentry *dentry,
1626                     int kind)
1627
1628 {
1629         struct inode_security_struct *dsec, *isec;
1630         struct common_audit_data ad;
1631         u32 sid = current_sid();
1632         u32 av;
1633         int rc;
1634
1635         dsec = dir->i_security;
1636         isec = dentry->d_inode->i_security;
1637
1638         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1639         ad.u.dentry = dentry;
1640
1641         av = DIR__SEARCH;
1642         av |= (kind ? DIR__REMOVE_NAME : DIR__ADD_NAME);
1643         rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR, av, &ad);
1644         if (rc)
1645                 return rc;
1646
1647         switch (kind) {
1648         case MAY_LINK:
1649                 av = FILE__LINK;
1650                 break;
1651         case MAY_UNLINK:
1652                 av = FILE__UNLINK;
1653                 break;
1654         case MAY_RMDIR:
1655                 av = DIR__RMDIR;
1656                 break;
1657         default:
1658                 printk(KERN_WARNING "SELinux: %s:  unrecognized kind %d\n",
1659                         __func__, kind);
1660                 return 0;
1661         }
1662
1663         rc = avc_has_perm(sid, isec->sid, isec->sclass, av, &ad);
1664         return rc;
1665 }
1666
1667 static inline int may_rename(struct inode *old_dir,
1668                              struct dentry *old_dentry,
1669                              struct inode *new_dir,
1670                              struct dentry *new_dentry)
1671 {
1672         struct inode_security_struct *old_dsec, *new_dsec, *old_isec, *new_isec;
1673         struct common_audit_data ad;
1674         u32 sid = current_sid();
1675         u32 av;
1676         int old_is_dir, new_is_dir;
1677         int rc;
1678
1679         old_dsec = old_dir->i_security;
1680         old_isec = old_dentry->d_inode->i_security;
1681         old_is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
1682         new_dsec = new_dir->i_security;
1683
1684         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
1685
1686         ad.u.dentry = old_dentry;
1687         rc = avc_has_perm(sid, old_dsec->sid, SECCLASS_DIR,
1688                           DIR__REMOVE_NAME | DIR__SEARCH, &ad);
1689         if (rc)
1690                 return rc;
1691         rc = avc_has_perm(sid, old_isec->sid,
1692                           old_isec->sclass, FILE__RENAME, &ad);
1693         if (rc)
1694                 return rc;
1695         if (old_is_dir && new_dir != old_dir) {
1696                 rc = avc_has_perm(sid, old_isec->sid,
1697                                   old_isec->sclass, DIR__REPARENT, &ad);
1698                 if (rc)
1699                         return rc;
1700         }
1701
1702         ad.u.dentry = new_dentry;
1703         av = DIR__ADD_NAME | DIR__SEARCH;
1704         if (new_dentry->d_inode)
1705                 av |= DIR__REMOVE_NAME;
1706         rc = avc_has_perm(sid, new_dsec->sid, SECCLASS_DIR, av, &ad);
1707         if (rc)
1708                 return rc;
1709         if (new_dentry->d_inode) {
1710                 new_isec = new_dentry->d_inode->i_security;
1711                 new_is_dir = S_ISDIR(new_dentry->d_inode->i_mode);
1712                 rc = avc_has_perm(sid, new_isec->sid,
1713                                   new_isec->sclass,
1714                                   (new_is_dir ? DIR__RMDIR : FILE__UNLINK), &ad);
1715                 if (rc)
1716                         return rc;
1717         }
1718
1719         return 0;
1720 }
1721
1722 /* Check whether a task can perform a filesystem operation. */
1723 static int superblock_has_perm(const struct cred *cred,
1724                                struct super_block *sb,
1725                                u32 perms,
1726                                struct common_audit_data *ad)
1727 {
1728         struct superblock_security_struct *sbsec;
1729         u32 sid = cred_sid(cred);
1730
1731         sbsec = sb->s_security;
1732         return avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM, perms, ad);
1733 }
1734
1735 /* Convert a Linux mode and permission mask to an access vector. */
1736 static inline u32 file_mask_to_av(int mode, int mask)
1737 {
1738         u32 av = 0;
1739
1740         if ((mode & S_IFMT) != S_IFDIR) {
1741                 if (mask & MAY_EXEC)
1742                         av |= FILE__EXECUTE;
1743                 if (mask & MAY_READ)
1744                         av |= FILE__READ;
1745
1746                 if (mask & MAY_APPEND)
1747                         av |= FILE__APPEND;
1748                 else if (mask & MAY_WRITE)
1749                         av |= FILE__WRITE;
1750
1751         } else {
1752                 if (mask & MAY_EXEC)
1753                         av |= DIR__SEARCH;
1754                 if (mask & MAY_WRITE)
1755                         av |= DIR__WRITE;
1756                 if (mask & MAY_READ)
1757                         av |= DIR__READ;
1758         }
1759
1760         return av;
1761 }
1762
1763 /* Convert a Linux file to an access vector. */
1764 static inline u32 file_to_av(struct file *file)
1765 {
1766         u32 av = 0;
1767
1768         if (file->f_mode & FMODE_READ)
1769                 av |= FILE__READ;
1770         if (file->f_mode & FMODE_WRITE) {
1771                 if (file->f_flags & O_APPEND)
1772                         av |= FILE__APPEND;
1773                 else
1774                         av |= FILE__WRITE;
1775         }
1776         if (!av) {
1777                 /*
1778                  * Special file opened with flags 3 for ioctl-only use.
1779                  */
1780                 av = FILE__IOCTL;
1781         }
1782
1783         return av;
1784 }
1785
1786 /*
1787  * Convert a file to an access vector and include the correct open
1788  * open permission.
1789  */
1790 static inline u32 open_file_to_av(struct file *file)
1791 {
1792         u32 av = file_to_av(file);
1793
1794         if (selinux_policycap_openperm)
1795                 av |= FILE__OPEN;
1796
1797         return av;
1798 }
1799
1800 /* Hook functions begin here. */
1801
1802 static int selinux_ptrace_access_check(struct task_struct *child,
1803                                      unsigned int mode)
1804 {
1805         int rc;
1806
1807         rc = cap_ptrace_access_check(child, mode);
1808         if (rc)
1809                 return rc;
1810
1811         if (mode == PTRACE_MODE_READ) {
1812                 u32 sid = current_sid();
1813                 u32 csid = task_sid(child);
1814                 return avc_has_perm(sid, csid, SECCLASS_FILE, FILE__READ, NULL);
1815         }
1816
1817         return current_has_perm(child, PROCESS__PTRACE);
1818 }
1819
1820 static int selinux_ptrace_traceme(struct task_struct *parent)
1821 {
1822         int rc;
1823
1824         rc = cap_ptrace_traceme(parent);
1825         if (rc)
1826                 return rc;
1827
1828         return task_has_perm(parent, current, PROCESS__PTRACE);
1829 }
1830
1831 static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
1832                           kernel_cap_t *inheritable, kernel_cap_t *permitted)
1833 {
1834         int error;
1835
1836         error = current_has_perm(target, PROCESS__GETCAP);
1837         if (error)
1838                 return error;
1839
1840         return cap_capget(target, effective, inheritable, permitted);
1841 }
1842
1843 static int selinux_capset(struct cred *new, const struct cred *old,
1844                           const kernel_cap_t *effective,
1845                           const kernel_cap_t *inheritable,
1846                           const kernel_cap_t *permitted)
1847 {
1848         int error;
1849
1850         error = cap_capset(new, old,
1851                                       effective, inheritable, permitted);
1852         if (error)
1853                 return error;
1854
1855         return cred_has_perm(old, new, PROCESS__SETCAP);
1856 }
1857
1858 /*
1859  * (This comment used to live with the selinux_task_setuid hook,
1860  * which was removed).
1861  *
1862  * Since setuid only affects the current process, and since the SELinux
1863  * controls are not based on the Linux identity attributes, SELinux does not
1864  * need to control this operation.  However, SELinux does control the use of
1865  * the CAP_SETUID and CAP_SETGID capabilities using the capable hook.
1866  */
1867
1868 static int selinux_capable(struct task_struct *tsk, const struct cred *cred,
1869                            int cap, int audit)
1870 {
1871         int rc;
1872
1873         rc = cap_capable(tsk, cred, cap, audit);
1874         if (rc)
1875                 return rc;
1876
1877         return task_has_capability(tsk, cred, cap, audit);
1878 }
1879
1880 static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
1881 {
1882         const struct cred *cred = current_cred();
1883         int rc = 0;
1884
1885         if (!sb)
1886                 return 0;
1887
1888         switch (cmds) {
1889         case Q_SYNC:
1890         case Q_QUOTAON:
1891         case Q_QUOTAOFF:
1892         case Q_SETINFO:
1893         case Q_SETQUOTA:
1894                 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAMOD, NULL);
1895                 break;
1896         case Q_GETFMT:
1897         case Q_GETINFO:
1898         case Q_GETQUOTA:
1899                 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAGET, NULL);
1900                 break;
1901         default:
1902                 rc = 0;  /* let the kernel handle invalid cmds */
1903                 break;
1904         }
1905         return rc;
1906 }
1907
1908 static int selinux_quota_on(struct dentry *dentry)
1909 {
1910         const struct cred *cred = current_cred();
1911
1912         return dentry_has_perm(cred, dentry, FILE__QUOTAON);
1913 }
1914
1915 static int selinux_syslog(int type)
1916 {
1917         int rc;
1918
1919         switch (type) {
1920         case SYSLOG_ACTION_READ_ALL:    /* Read last kernel messages */
1921         case SYSLOG_ACTION_SIZE_BUFFER: /* Return size of the log buffer */
1922                 rc = task_has_system(current, SYSTEM__SYSLOG_READ);
1923                 break;
1924         case SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging to console */
1925         case SYSLOG_ACTION_CONSOLE_ON:  /* Enable logging to console */
1926         /* Set level of messages printed to console */
1927         case SYSLOG_ACTION_CONSOLE_LEVEL:
1928                 rc = task_has_system(current, SYSTEM__SYSLOG_CONSOLE);
1929                 break;
1930         case SYSLOG_ACTION_CLOSE:       /* Close log */
1931         case SYSLOG_ACTION_OPEN:        /* Open log */
1932         case SYSLOG_ACTION_READ:        /* Read from log */
1933         case SYSLOG_ACTION_READ_CLEAR:  /* Read/clear last kernel messages */
1934         case SYSLOG_ACTION_CLEAR:       /* Clear ring buffer */
1935         default:
1936                 rc = task_has_system(current, SYSTEM__SYSLOG_MOD);
1937                 break;
1938         }
1939         return rc;
1940 }
1941
1942 /*
1943  * Check that a process has enough memory to allocate a new virtual
1944  * mapping. 0 means there is enough memory for the allocation to
1945  * succeed and -ENOMEM implies there is not.
1946  *
1947  * Do not audit the selinux permission check, as this is applied to all
1948  * processes that allocate mappings.
1949  */
1950 static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
1951 {
1952         int rc, cap_sys_admin = 0;
1953
1954         rc = selinux_capable(current, current_cred(), CAP_SYS_ADMIN,
1955                              SECURITY_CAP_NOAUDIT);
1956         if (rc == 0)
1957                 cap_sys_admin = 1;
1958
1959         return __vm_enough_memory(mm, pages, cap_sys_admin);
1960 }
1961
1962 /* binprm security operations */
1963
1964 static int selinux_bprm_set_creds(struct linux_binprm *bprm)
1965 {
1966         const struct task_security_struct *old_tsec;
1967         struct task_security_struct *new_tsec;
1968         struct inode_security_struct *isec;
1969         struct common_audit_data ad;
1970         struct inode *inode = bprm->file->f_path.dentry->d_inode;
1971         int rc;
1972
1973         rc = cap_bprm_set_creds(bprm);
1974         if (rc)
1975                 return rc;
1976
1977         /* SELinux context only depends on initial program or script and not
1978          * the script interpreter */
1979         if (bprm->cred_prepared)
1980                 return 0;
1981
1982         old_tsec = current_security();
1983         new_tsec = bprm->cred->security;
1984         isec = inode->i_security;
1985
1986         /* Default to the current task SID. */
1987         new_tsec->sid = old_tsec->sid;
1988         new_tsec->osid = old_tsec->sid;
1989
1990         /* Reset fs, key, and sock SIDs on execve. */
1991         new_tsec->create_sid = 0;
1992         new_tsec->keycreate_sid = 0;
1993         new_tsec->sockcreate_sid = 0;
1994
1995         if (old_tsec->exec_sid) {
1996                 new_tsec->sid = old_tsec->exec_sid;
1997                 /* Reset exec SID on execve. */
1998                 new_tsec->exec_sid = 0;
1999         } else {
2000                 /* Check for a default transition on this program. */
2001                 rc = security_transition_sid(old_tsec->sid, isec->sid,
2002                                              SECCLASS_PROCESS, NULL,
2003                                              &new_tsec->sid);
2004                 if (rc)
2005                         return rc;
2006         }
2007
2008         COMMON_AUDIT_DATA_INIT(&ad, PATH);
2009         ad.u.path = bprm->file->f_path;
2010
2011         if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
2012                 new_tsec->sid = old_tsec->sid;
2013
2014         if (new_tsec->sid == old_tsec->sid) {
2015                 rc = avc_has_perm(old_tsec->sid, isec->sid,
2016                                   SECCLASS_FILE, FILE__EXECUTE_NO_TRANS, &ad);
2017                 if (rc)
2018                         return rc;
2019         } else {
2020                 /* Check permissions for the transition. */
2021                 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2022                                   SECCLASS_PROCESS, PROCESS__TRANSITION, &ad);
2023                 if (rc)
2024                         return rc;
2025
2026                 rc = avc_has_perm(new_tsec->sid, isec->sid,
2027                                   SECCLASS_FILE, FILE__ENTRYPOINT, &ad);
2028                 if (rc)
2029                         return rc;
2030
2031                 /* Check for shared state */
2032                 if (bprm->unsafe & LSM_UNSAFE_SHARE) {
2033                         rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2034                                           SECCLASS_PROCESS, PROCESS__SHARE,
2035                                           NULL);
2036                         if (rc)
2037                                 return -EPERM;
2038                 }
2039
2040                 /* Make sure that anyone attempting to ptrace over a task that
2041                  * changes its SID has the appropriate permit */
2042                 if (bprm->unsafe &
2043                     (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
2044                         struct task_struct *tracer;
2045                         struct task_security_struct *sec;
2046                         u32 ptsid = 0;
2047
2048                         rcu_read_lock();
2049                         tracer = tracehook_tracer_task(current);
2050                         if (likely(tracer != NULL)) {
2051                                 sec = __task_cred(tracer)->security;
2052                                 ptsid = sec->sid;
2053                         }
2054                         rcu_read_unlock();
2055
2056                         if (ptsid != 0) {
2057                                 rc = avc_has_perm(ptsid, new_tsec->sid,
2058                                                   SECCLASS_PROCESS,
2059                                                   PROCESS__PTRACE, NULL);
2060                                 if (rc)
2061                                         return -EPERM;
2062                         }
2063                 }
2064
2065                 /* Clear any possibly unsafe personality bits on exec: */
2066                 bprm->per_clear |= PER_CLEAR_ON_SETID;
2067         }
2068
2069         return 0;
2070 }
2071
2072 static int selinux_bprm_secureexec(struct linux_binprm *bprm)
2073 {
2074         const struct task_security_struct *tsec = current_security();
2075         u32 sid, osid;
2076         int atsecure = 0;
2077
2078         sid = tsec->sid;
2079         osid = tsec->osid;
2080
2081         if (osid != sid) {
2082                 /* Enable secure mode for SIDs transitions unless
2083                    the noatsecure permission is granted between
2084                    the two SIDs, i.e. ahp returns 0. */
2085                 atsecure = avc_has_perm(osid, sid,
2086                                         SECCLASS_PROCESS,
2087                                         PROCESS__NOATSECURE, NULL);
2088         }
2089
2090         return (atsecure || cap_bprm_secureexec(bprm));
2091 }
2092
2093 extern struct vfsmount *selinuxfs_mount;
2094 extern struct dentry *selinux_null;
2095
2096 /* Derived from fs/exec.c:flush_old_files. */
2097 static inline void flush_unauthorized_files(const struct cred *cred,
2098                                             struct files_struct *files)
2099 {
2100         struct common_audit_data ad;
2101         struct file *file, *devnull = NULL;
2102         struct tty_struct *tty;
2103         struct fdtable *fdt;
2104         long j = -1;
2105         int drop_tty = 0;
2106
2107         tty = get_current_tty();
2108         if (tty) {
2109                 spin_lock(&tty_files_lock);
2110                 if (!list_empty(&tty->tty_files)) {
2111                         struct tty_file_private *file_priv;
2112                         struct inode *inode;
2113
2114                         /* Revalidate access to controlling tty.
2115                            Use inode_has_perm on the tty inode directly rather
2116                            than using file_has_perm, as this particular open
2117                            file may belong to another process and we are only
2118                            interested in the inode-based check here. */
2119                         file_priv = list_first_entry(&tty->tty_files,
2120                                                 struct tty_file_private, list);
2121                         file = file_priv->file;
2122                         inode = file->f_path.dentry->d_inode;
2123                         if (inode_has_perm(cred, inode,
2124                                            FILE__READ | FILE__WRITE, NULL, 0)) {
2125                                 drop_tty = 1;
2126                         }
2127                 }
2128                 spin_unlock(&tty_files_lock);
2129                 tty_kref_put(tty);
2130         }
2131         /* Reset controlling tty. */
2132         if (drop_tty)
2133                 no_tty();
2134
2135         /* Revalidate access to inherited open files. */
2136
2137         COMMON_AUDIT_DATA_INIT(&ad, INODE);
2138
2139         spin_lock(&files->file_lock);
2140         for (;;) {
2141                 unsigned long set, i;
2142                 int fd;
2143
2144                 j++;
2145                 i = j * __NFDBITS;
2146                 fdt = files_fdtable(files);
2147                 if (i >= fdt->max_fds)
2148                         break;
2149                 set = fdt->open_fds->fds_bits[j];
2150                 if (!set)
2151                         continue;
2152                 spin_unlock(&files->file_lock);
2153                 for ( ; set ; i++, set >>= 1) {
2154                         if (set & 1) {
2155                                 file = fget(i);
2156                                 if (!file)
2157                                         continue;
2158                                 if (file_has_perm(cred,
2159                                                   file,
2160                                                   file_to_av(file))) {
2161                                         sys_close(i);
2162                                         fd = get_unused_fd();
2163                                         if (fd != i) {
2164                                                 if (fd >= 0)
2165                                                         put_unused_fd(fd);
2166                                                 fput(file);
2167                                                 continue;
2168                                         }
2169                                         if (devnull) {
2170                                                 get_file(devnull);
2171                                         } else {
2172                                                 devnull = dentry_open(
2173                                                         dget(selinux_null),
2174                                                         mntget(selinuxfs_mount),
2175                                                         O_RDWR, cred);
2176                                                 if (IS_ERR(devnull)) {
2177                                                         devnull = NULL;
2178                                                         put_unused_fd(fd);
2179                                                         fput(file);
2180                                                         continue;
2181                                                 }
2182                                         }
2183                                         fd_install(fd, devnull);
2184                                 }
2185                                 fput(file);
2186                         }
2187                 }
2188                 spin_lock(&files->file_lock);
2189
2190         }
2191         spin_unlock(&files->file_lock);
2192 }
2193
2194 /*
2195  * Prepare a process for imminent new credential changes due to exec
2196  */
2197 static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
2198 {
2199         struct task_security_struct *new_tsec;
2200         struct rlimit *rlim, *initrlim;
2201         int rc, i;
2202
2203         new_tsec = bprm->cred->security;
2204         if (new_tsec->sid == new_tsec->osid)
2205                 return;
2206
2207         /* Close files for which the new task SID is not authorized. */
2208         flush_unauthorized_files(bprm->cred, current->files);
2209
2210         /* Always clear parent death signal on SID transitions. */
2211         current->pdeath_signal = 0;
2212
2213         /* Check whether the new SID can inherit resource limits from the old
2214          * SID.  If not, reset all soft limits to the lower of the current
2215          * task's hard limit and the init task's soft limit.
2216          *
2217          * Note that the setting of hard limits (even to lower them) can be
2218          * controlled by the setrlimit check.  The inclusion of the init task's
2219          * soft limit into the computation is to avoid resetting soft limits
2220          * higher than the default soft limit for cases where the default is
2221          * lower than the hard limit, e.g. RLIMIT_CORE or RLIMIT_STACK.
2222          */
2223         rc = avc_has_perm(new_tsec->osid, new_tsec->sid, SECCLASS_PROCESS,
2224                           PROCESS__RLIMITINH, NULL);
2225         if (rc) {
2226                 /* protect against do_prlimit() */
2227                 task_lock(current);
2228                 for (i = 0; i < RLIM_NLIMITS; i++) {
2229                         rlim = current->signal->rlim + i;
2230                         initrlim = init_task.signal->rlim + i;
2231                         rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
2232                 }
2233                 task_unlock(current);
2234                 update_rlimit_cpu(current, rlimit(RLIMIT_CPU));
2235         }
2236 }
2237
2238 /*
2239  * Clean up the process immediately after the installation of new credentials
2240  * due to exec
2241  */
2242 static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
2243 {
2244         const struct task_security_struct *tsec = current_security();
2245         struct itimerval itimer;
2246         u32 osid, sid;
2247         int rc, i;
2248
2249         osid = tsec->osid;
2250         sid = tsec->sid;
2251
2252         if (sid == osid)
2253                 return;
2254
2255         /* Check whether the new SID can inherit signal state from the old SID.
2256          * If not, clear itimers to avoid subsequent signal generation and
2257          * flush and unblock signals.
2258          *
2259          * This must occur _after_ the task SID has been updated so that any
2260          * kill done after the flush will be checked against the new SID.
2261          */
2262         rc = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__SIGINH, NULL);
2263         if (rc) {
2264                 memset(&itimer, 0, sizeof itimer);
2265                 for (i = 0; i < 3; i++)
2266                         do_setitimer(i, &itimer, NULL);
2267                 spin_lock_irq(&current->sighand->siglock);
2268                 if (!(current->signal->flags & SIGNAL_GROUP_EXIT)) {
2269                         __flush_signals(current);
2270                         flush_signal_handlers(current, 1);
2271                         sigemptyset(&current->blocked);
2272                 }
2273                 spin_unlock_irq(&current->sighand->siglock);
2274         }
2275
2276         /* Wake up the parent if it is waiting so that it can recheck
2277          * wait permission to the new task SID. */
2278         read_lock(&tasklist_lock);
2279         __wake_up_parent(current, current->real_parent);
2280         read_unlock(&tasklist_lock);
2281 }
2282
2283 /* superblock security operations */
2284
2285 static int selinux_sb_alloc_security(struct super_block *sb)
2286 {
2287         return superblock_alloc_security(sb);
2288 }
2289
2290 static void selinux_sb_free_security(struct super_block *sb)
2291 {
2292         superblock_free_security(sb);
2293 }
2294
2295 static inline int match_prefix(char *prefix, int plen, char *option, int olen)
2296 {
2297         if (plen > olen)
2298                 return 0;
2299
2300         return !memcmp(prefix, option, plen);
2301 }
2302
2303 static inline int selinux_option(char *option, int len)
2304 {
2305         return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) ||
2306                 match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) ||
2307                 match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) ||
2308                 match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) ||
2309                 match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len));
2310 }
2311
2312 static inline void take_option(char **to, char *from, int *first, int len)
2313 {
2314         if (!*first) {
2315                 **to = ',';
2316                 *to += 1;
2317         } else
2318                 *first = 0;
2319         memcpy(*to, from, len);
2320         *to += len;
2321 }
2322
2323 static inline void take_selinux_option(char **to, char *from, int *first,
2324                                        int len)
2325 {
2326         int current_size = 0;
2327
2328         if (!*first) {
2329                 **to = '|';
2330                 *to += 1;
2331         } else
2332                 *first = 0;
2333
2334         while (current_size < len) {
2335                 if (*from != '"') {
2336                         **to = *from;
2337                         *to += 1;
2338                 }
2339                 from += 1;
2340                 current_size += 1;
2341         }
2342 }
2343
2344 static int selinux_sb_copy_data(char *orig, char *copy)
2345 {
2346         int fnosec, fsec, rc = 0;
2347         char *in_save, *in_curr, *in_end;
2348         char *sec_curr, *nosec_save, *nosec;
2349         int open_quote = 0;
2350
2351         in_curr = orig;
2352         sec_curr = copy;
2353
2354         nosec = (char *)get_zeroed_page(GFP_KERNEL);
2355         if (!nosec) {
2356                 rc = -ENOMEM;
2357                 goto out;
2358         }
2359
2360         nosec_save = nosec;
2361         fnosec = fsec = 1;
2362         in_save = in_end = orig;
2363
2364         do {
2365                 if (*in_end == '"')
2366                         open_quote = !open_quote;
2367                 if ((*in_end == ',' && open_quote == 0) ||
2368                                 *in_end == '\0') {
2369                         int len = in_end - in_curr;
2370
2371                         if (selinux_option(in_curr, len))
2372                                 take_selinux_option(&sec_curr, in_curr, &fsec, len);
2373                         else
2374                                 take_option(&nosec, in_curr, &fnosec, len);
2375
2376                         in_curr = in_end + 1;
2377                 }
2378         } while (*in_end++);
2379
2380         strcpy(in_save, nosec_save);
2381         free_page((unsigned long)nosec_save);
2382 out:
2383         return rc;
2384 }
2385
2386 static int selinux_sb_remount(struct super_block *sb, void *data)
2387 {
2388         int rc, i, *flags;
2389         struct security_mnt_opts opts;
2390         char *secdata, **mount_options;
2391         struct superblock_security_struct *sbsec = sb->s_security;
2392
2393         if (!(sbsec->flags & SE_SBINITIALIZED))
2394                 return 0;
2395
2396         if (!data)
2397                 return 0;
2398
2399         if (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
2400                 return 0;
2401
2402         security_init_mnt_opts(&opts);
2403         secdata = alloc_secdata();
2404         if (!secdata)
2405                 return -ENOMEM;
2406         rc = selinux_sb_copy_data(data, secdata);
2407         if (rc)
2408                 goto out_free_secdata;
2409
2410         rc = selinux_parse_opts_str(secdata, &opts);
2411         if (rc)
2412                 goto out_free_secdata;
2413
2414         mount_options = opts.mnt_opts;
2415         flags = opts.mnt_opts_flags;
2416
2417         for (i = 0; i < opts.num_mnt_opts; i++) {
2418                 u32 sid;
2419                 size_t len;
2420
2421                 if (flags[i] == SE_SBLABELSUPP)
2422                         continue;
2423                 len = strlen(mount_options[i]);
2424                 rc = security_context_to_sid(mount_options[i], len, &sid);
2425                 if (rc) {
2426                         printk(KERN_WARNING "SELinux: security_context_to_sid"
2427                                "(%s) failed for (dev %s, type %s) errno=%d\n",
2428                                mount_options[i], sb->s_id, sb->s_type->name, rc);
2429                         goto out_free_opts;
2430                 }
2431                 rc = -EINVAL;
2432                 switch (flags[i]) {
2433                 case FSCONTEXT_MNT:
2434                         if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid, sid))
2435                                 goto out_bad_option;
2436                         break;
2437                 case CONTEXT_MNT:
2438                         if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid, sid))
2439                                 goto out_bad_option;
2440                         break;
2441                 case ROOTCONTEXT_MNT: {
2442                         struct inode_security_struct *root_isec;
2443                         root_isec = sb->s_root->d_inode->i_security;
2444
2445                         if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, sid))
2446                                 goto out_bad_option;
2447                         break;
2448                 }
2449                 case DEFCONTEXT_MNT:
2450                         if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid, sid))
2451                                 goto out_bad_option;
2452                         break;
2453                 default:
2454                         goto out_free_opts;
2455                 }
2456         }
2457
2458         rc = 0;
2459 out_free_opts:
2460         security_free_mnt_opts(&opts);
2461 out_free_secdata:
2462         free_secdata(secdata);
2463         return rc;
2464 out_bad_option:
2465         printk(KERN_WARNING "SELinux: unable to change security options "
2466                "during remount (dev %s, type=%s)\n", sb->s_id,
2467                sb->s_type->name);
2468         goto out_free_opts;
2469 }
2470
2471 static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data)
2472 {
2473         const struct cred *cred = current_cred();
2474         struct common_audit_data ad;
2475         int rc;
2476
2477         rc = superblock_doinit(sb, data);
2478         if (rc)
2479                 return rc;
2480
2481         /* Allow all mounts performed by the kernel */
2482         if (flags & MS_KERNMOUNT)
2483                 return 0;
2484
2485         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
2486         ad.u.dentry = sb->s_root;
2487         return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
2488 }
2489
2490 static int selinux_sb_statfs(struct dentry *dentry)
2491 {
2492         const struct cred *cred = current_cred();
2493         struct common_audit_data ad;
2494
2495         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
2496         ad.u.dentry = dentry->d_sb->s_root;
2497         return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad);
2498 }
2499
2500 static int selinux_mount(char *dev_name,
2501                          struct path *path,
2502                          char *type,
2503                          unsigned long flags,
2504                          void *data)
2505 {
2506         const struct cred *cred = current_cred();
2507
2508         if (flags & MS_REMOUNT)
2509                 return superblock_has_perm(cred, path->mnt->mnt_sb,
2510                                            FILESYSTEM__REMOUNT, NULL);
2511         else
2512                 return path_has_perm(cred, path, FILE__MOUNTON);
2513 }
2514
2515 static int selinux_umount(struct vfsmount *mnt, int flags)
2516 {
2517         const struct cred *cred = current_cred();
2518
2519         return superblock_has_perm(cred, mnt->mnt_sb,
2520                                    FILESYSTEM__UNMOUNT, NULL);
2521 }
2522
2523 /* inode security operations */
2524
2525 static int selinux_inode_alloc_security(struct inode *inode)
2526 {
2527         return inode_alloc_security(inode);
2528 }
2529
2530 static void selinux_inode_free_security(struct inode *inode)
2531 {
2532         inode_free_security(inode);
2533 }
2534
2535 static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
2536                                        const struct qstr *qstr, char **name,
2537                                        void **value, size_t *len)
2538 {
2539         const struct task_security_struct *tsec = current_security();
2540         struct inode_security_struct *dsec;
2541         struct superblock_security_struct *sbsec;
2542         u32 sid, newsid, clen;
2543         int rc;
2544         char *namep = NULL, *context;
2545
2546         dsec = dir->i_security;
2547         sbsec = dir->i_sb->s_security;
2548
2549         sid = tsec->sid;
2550         newsid = tsec->create_sid;
2551
2552         if ((sbsec->flags & SE_SBINITIALIZED) &&
2553             (sbsec->behavior == SECURITY_FS_USE_MNTPOINT))
2554                 newsid = sbsec->mntpoint_sid;
2555         else if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
2556                 rc = security_transition_sid(sid, dsec->sid,
2557                                              inode_mode_to_security_class(inode->i_mode),
2558                                              qstr, &newsid);
2559                 if (rc) {
2560                         printk(KERN_WARNING "%s:  "
2561                                "security_transition_sid failed, rc=%d (dev=%s "
2562                                "ino=%ld)\n",
2563                                __func__,
2564                                -rc, inode->i_sb->s_id, inode->i_ino);
2565                         return rc;
2566                 }
2567         }
2568
2569         /* Possibly defer initialization to selinux_complete_init. */
2570         if (sbsec->flags & SE_SBINITIALIZED) {
2571                 struct inode_security_struct *isec = inode->i_security;
2572                 isec->sclass = inode_mode_to_security_class(inode->i_mode);
2573                 isec->sid = newsid;
2574                 isec->initialized = 1;
2575         }
2576
2577         if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
2578                 return -EOPNOTSUPP;
2579
2580         if (name) {
2581                 namep = kstrdup(XATTR_SELINUX_SUFFIX, GFP_NOFS);
2582                 if (!namep)
2583                         return -ENOMEM;
2584                 *name = namep;
2585         }
2586
2587         if (value && len) {
2588                 rc = security_sid_to_context_force(newsid, &context, &clen);
2589                 if (rc) {
2590                         kfree(namep);
2591                         return rc;
2592                 }
2593                 *value = context;
2594                 *len = clen;
2595         }
2596
2597         return 0;
2598 }
2599
2600 static int selinux_inode_create(struct inode *dir, struct dentry *dentry, int mask)
2601 {
2602         return may_create(dir, dentry, SECCLASS_FILE);
2603 }
2604
2605 static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2606 {
2607         return may_link(dir, old_dentry, MAY_LINK);
2608 }
2609
2610 static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry)
2611 {
2612         return may_link(dir, dentry, MAY_UNLINK);
2613 }
2614
2615 static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name)
2616 {
2617         return may_create(dir, dentry, SECCLASS_LNK_FILE);
2618 }
2619
2620 static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, int mask)
2621 {
2622         return may_create(dir, dentry, SECCLASS_DIR);
2623 }
2624
2625 static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry)
2626 {
2627         return may_link(dir, dentry, MAY_RMDIR);
2628 }
2629
2630 static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2631 {
2632         return may_create(dir, dentry, inode_mode_to_security_class(mode));
2633 }
2634
2635 static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry,
2636                                 struct inode *new_inode, struct dentry *new_dentry)
2637 {
2638         return may_rename(old_inode, old_dentry, new_inode, new_dentry);
2639 }
2640
2641 static int selinux_inode_readlink(struct dentry *dentry)
2642 {
2643         const struct cred *cred = current_cred();
2644
2645         return dentry_has_perm(cred, dentry, FILE__READ);
2646 }
2647
2648 static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *nameidata)
2649 {
2650         const struct cred *cred = current_cred();
2651
2652         return dentry_has_perm(cred, dentry, FILE__READ);
2653 }
2654
2655 static int selinux_inode_permission(struct inode *inode, int mask, unsigned flags)
2656 {
2657         const struct cred *cred = current_cred();
2658         struct common_audit_data ad;
2659         u32 perms;
2660         bool from_access;
2661
2662         from_access = mask & MAY_ACCESS;
2663         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
2664
2665         /* No permission to check.  Existence test. */
2666         if (!mask)
2667                 return 0;
2668
2669         COMMON_AUDIT_DATA_INIT(&ad, INODE);
2670         ad.u.inode = inode;
2671
2672         if (from_access)
2673                 ad.selinux_audit_data.auditdeny |= FILE__AUDIT_ACCESS;
2674
2675         perms = file_mask_to_av(inode->i_mode, mask);
2676
2677         return inode_has_perm(cred, inode, perms, &ad, flags);
2678 }
2679
2680 static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
2681 {
2682         const struct cred *cred = current_cred();
2683         unsigned int ia_valid = iattr->ia_valid;
2684
2685         /* ATTR_FORCE is just used for ATTR_KILL_S[UG]ID. */
2686         if (ia_valid & ATTR_FORCE) {
2687                 ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_MODE |
2688                               ATTR_FORCE);
2689                 if (!ia_valid)
2690                         return 0;
2691         }
2692
2693         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID |
2694                         ATTR_ATIME_SET | ATTR_MTIME_SET | ATTR_TIMES_SET))
2695                 return dentry_has_perm(cred, dentry, FILE__SETATTR);
2696
2697         return dentry_has_perm(cred, dentry, FILE__WRITE);
2698 }
2699
2700 static int selinux_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
2701 {
2702         const struct cred *cred = current_cred();
2703         struct path path;
2704
2705         path.dentry = dentry;
2706         path.mnt = mnt;
2707
2708         return path_has_perm(cred, &path, FILE__GETATTR);
2709 }
2710
2711 static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name)
2712 {
2713         const struct cred *cred = current_cred();
2714
2715         if (!strncmp(name, XATTR_SECURITY_PREFIX,
2716                      sizeof XATTR_SECURITY_PREFIX - 1)) {
2717                 if (!strcmp(name, XATTR_NAME_CAPS)) {
2718                         if (!capable(CAP_SETFCAP))
2719                                 return -EPERM;
2720                 } else if (!capable(CAP_SYS_ADMIN)) {
2721                         /* A different attribute in the security namespace.
2722                            Restrict to administrator. */
2723                         return -EPERM;
2724                 }
2725         }
2726
2727         /* Not an attribute we recognize, so just check the
2728            ordinary setattr permission. */
2729         return dentry_has_perm(cred, dentry, FILE__SETATTR);
2730 }
2731
2732 static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
2733                                   const void *value, size_t size, int flags)
2734 {
2735         struct inode *inode = dentry->d_inode;
2736         struct inode_security_struct *isec = inode->i_security;
2737         struct superblock_security_struct *sbsec;
2738         struct common_audit_data ad;
2739         u32 newsid, sid = current_sid();
2740         int rc = 0;
2741
2742         if (strcmp(name, XATTR_NAME_SELINUX))
2743                 return selinux_inode_setotherxattr(dentry, name);
2744
2745         sbsec = inode->i_sb->s_security;
2746         if (!(sbsec->flags & SE_SBLABELSUPP))
2747                 return -EOPNOTSUPP;
2748
2749         if (!is_owner_or_cap(inode))
2750                 return -EPERM;
2751
2752         COMMON_AUDIT_DATA_INIT(&ad, DENTRY);
2753         ad.u.dentry = dentry;
2754
2755         rc = avc_has_perm(sid, isec->sid, isec->sclass,
2756                           FILE__RELABELFROM, &ad);
2757         if (rc)
2758                 return rc;
2759
2760         rc = security_context_to_sid(value, size, &newsid);
2761         if (rc == -EINVAL) {
2762                 if (!capable(CAP_MAC_ADMIN))
2763                         return rc;
2764                 rc = security_context_to_sid_force(value, size, &newsid);
2765         }
2766         if (rc)
2767                 return rc;
2768
2769         rc = avc_has_perm(sid, newsid, isec->sclass,
2770                           FILE__RELABELTO, &ad);
2771         if (rc)
2772                 return rc;
2773
2774         rc = security_validate_transition(isec->sid, newsid, sid,
2775                                           isec->sclass);
2776         if (rc)
2777                 return rc;
2778
2779         return avc_has_perm(newsid,
2780                             sbsec->sid,
2781                             SECCLASS_FILESYSTEM,
2782                             FILESYSTEM__ASSOCIATE,
2783                             &ad);
2784 }
2785
2786 static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
2787                                         const void *value, size_t size,
2788                                         int flags)
2789 {
2790         struct inode *inode = dentry->d_inode;
2791         struct inode_security_struct *isec = inode->i_security;
2792         u32 newsid;
2793         int rc;
2794
2795         if (strcmp(name, XATTR_NAME_SELINUX)) {
2796                 /* Not an attribute we recognize, so nothing to do. */
2797                 return;
2798         }
2799
2800         rc = security_context_to_sid_force(value, size, &newsid);
2801         if (rc) {
2802                 printk(KERN_ERR "SELinux:  unable to map context to SID"
2803                        "for (%s, %lu), rc=%d\n",
2804                        inode->i_sb->s_id, inode->i_ino, -rc);
2805                 return;
2806         }
2807
2808         isec->sid = newsid;
2809         return;
2810 }
2811
2812 static int selinux_inode_getxattr(struct dentry *dentry, const char *name)
2813 {
2814         const struct cred *cred = current_cred();
2815
2816         return dentry_has_perm(cred, dentry, FILE__GETATTR);
2817 }
2818
2819 static int selinux_inode_listxattr(struct dentry *dentry)
2820 {
2821         const struct cred *cred = current_cred();
2822
2823         return dentry_has_perm(cred, dentry, FILE__GETATTR);
2824 }
2825
2826 static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
2827 {
2828         if (strcmp(name, XATTR_NAME_SELINUX))
2829                 return selinux_inode_setotherxattr(dentry, name);
2830
2831         /* No one is allowed to remove a SELinux security label.
2832            You can change the label, but all data must be labeled. */
2833         return -EACCES;
2834 }
2835
2836 /*
2837  * Copy the inode security context value to the user.
2838  *
2839  * Permission check is handled by selinux_inode_getxattr hook.
2840  */
2841 static int selinux_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
2842 {
2843         u32 size;
2844         int error;
2845         char *context = NULL;
2846         struct inode_security_struct *isec = inode->i_security;
2847
2848         if (strcmp(name, XATTR_SELINUX_SUFFIX))
2849                 return -EOPNOTSUPP;
2850
2851         /*
2852          * If the caller has CAP_MAC_ADMIN, then get the raw context
2853          * value even if it is not defined by current policy; otherwise,
2854          * use the in-core value under current policy.
2855          * Use the non-auditing forms of the permission checks since
2856          * getxattr may be called by unprivileged processes commonly
2857          * and lack of permission just means that we fall back to the
2858          * in-core context value, not a denial.
2859          */
2860         error = selinux_capable(current, current_cred(), CAP_MAC_ADMIN,
2861                                 SECURITY_CAP_NOAUDIT);
2862         if (!error)
2863                 error = security_sid_to_context_force(isec->sid, &context,
2864                                                       &size);
2865         else
2866                 error = security_sid_to_context(isec->sid, &context, &size);
2867         if (error)
2868                 return error;
2869         error = size;
2870         if (alloc) {
2871                 *buffer = context;
2872                 goto out_nofree;
2873         }
2874         kfree(context);
2875 out_nofree:
2876         return error;
2877 }
2878
2879 static int selinux_inode_setsecurity(struct inode *inode, const char *name,
2880                                      const void *value, size_t size, int flags)
2881 {
2882         struct inode_security_struct *isec = inode->i_security;
2883         u32 newsid;
2884         int rc;
2885
2886         if (strcmp(name, XATTR_SELINUX_SUFFIX))
2887                 return -EOPNOTSUPP;
2888
2889         if (!value || !size)
2890                 return -EACCES;
2891
2892         rc = security_context_to_sid((void *)value, size, &newsid);
2893         if (rc)
2894                 return rc;
2895
2896         isec->sid = newsid;
2897         isec->initialized = 1;
2898         return 0;
2899 }
2900
2901 static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
2902 {
2903         const int len = sizeof(XATTR_NAME_SELINUX);
2904         if (buffer && len <= buffer_size)
2905                 memcpy(buffer, XATTR_NAME_SELINUX, len);
2906         return len;
2907 }
2908
2909 static void selinux_inode_getsecid(const struct inode *inode, u32 *secid)
2910 {
2911         struct inode_security_struct *isec = inode->i_security;
2912         *secid = isec->sid;
2913 }
2914
2915 /* file security operations */
2916
2917 static int selinux_revalidate_file_permission(struct file *file, int mask)
2918 {
2919         const struct cred *cred = current_cred();
2920         struct inode *inode = file->f_path.dentry->d_inode;
2921
2922         /* file_mask_to_av won't add FILE__WRITE if MAY_APPEND is set */
2923         if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE))
2924                 mask |= MAY_APPEND;
2925
2926         return file_has_perm(cred, file,
2927                              file_mask_to_av(inode->i_mode, mask));
2928 }
2929
2930 static int selinux_file_permission(struct file *file, int mask)
2931 {
2932         struct inode *inode = file->f_path.dentry->d_inode;
2933         struct file_security_struct *fsec = file->f_security;
2934         struct inode_security_struct *isec = inode->i_security;
2935         u32 sid = current_sid();
2936
2937         if (!mask)
2938                 /* No permission to check.  Existence test. */
2939                 return 0;
2940
2941         if (sid == fsec->sid && fsec->isid == isec->sid &&
2942             fsec->pseqno == avc_policy_seqno())
2943                 /* No change since dentry_open check. */
2944                 return 0;
2945
2946         return selinux_revalidate_file_permission(file, mask);
2947 }
2948
2949 static int selinux_file_alloc_security(struct file *file)
2950 {
2951         return file_alloc_security(file);
2952 }
2953
2954 static void selinux_file_free_security(struct file *file)
2955 {
2956         file_free_security(file);
2957 }
2958
2959 static int selinux_file_ioctl(struct file *file, unsigned int cmd,
2960                               unsigned long arg)
2961 {
2962         const struct cred *cred = current_cred();
2963         int error = 0;
2964
2965         switch (cmd) {
2966         case FIONREAD:
2967         /* fall through */
2968         case FIBMAP:
2969         /* fall through */
2970         case FIGETBSZ:
2971         /* fall through */
2972         case EXT2_IOC_GETFLAGS:
2973         /* fall through */
2974         case EXT2_IOC_GETVERSION:
2975                 error = file_has_perm(cred, file, FILE__GETATTR);
2976                 break;
2977
2978         case EXT2_IOC_SETFLAGS:
2979         /* fall through */
2980         case EXT2_IOC_SETVERSION:
2981                 error = file_has_perm(cred, file, FILE__SETATTR);
2982                 break;
2983
2984         /* sys_ioctl() checks */
2985         case FIONBIO:
2986         /* fall through */
2987         case FIOASYNC:
2988                 error = file_has_perm(cred, file, 0);
2989                 break;
2990
2991         case KDSKBENT:
2992         case KDSKBSENT:
2993                 error = task_has_capability(current, cred, CAP_SYS_TTY_CONFIG,
2994                                             SECURITY_CAP_AUDIT);
2995                 break;
2996
2997         /* default case assumes that the command will go
2998          * to the file's ioctl() function.
2999          */
3000         default:
3001                 error = file_has_perm(cred, file, FILE__IOCTL);
3002         }
3003         return error;
3004 }
3005
3006 static int default_noexec;
3007
3008 static int file_map_prot_check(struct file *file, unsigned long prot, int shared)
3009 {
3010         const struct cred *cred = current_cred();
3011         int rc = 0;
3012
3013         if (default_noexec &&
3014             (prot & PROT_EXEC) && (!file || (!shared && (prot & PROT_WRITE)))) {
3015                 /*
3016                  * We are making executable an anonymous mapping or a
3017                  * private file mapping that will also be writable.
3018                  * This has an additional check.
3019                  */
3020                 rc = cred_has_perm(cred, cred, PROCESS__EXECMEM);
3021                 if (rc)
3022                         goto error;
3023         }
3024
3025         if (file) {
3026                 /* read access is always possible with a mapping */
3027                 u32 av = FILE__READ;
3028
3029                 /* write access only matters if the mapping is shared */
3030                 if (shared && (prot & PROT_WRITE))
3031                         av |= FILE__WRITE;
3032
3033                 if (prot & PROT_EXEC)
3034                         av |= FILE__EXECUTE;
3035
3036                 return file_has_perm(cred, file, av);
3037         }
3038
3039 error:
3040         return rc;
3041 }
3042
3043 static int selinux_file_mmap(struct file *file, unsigned long reqprot,
3044                              unsigned long prot, unsigned long flags,
3045                              unsigned long addr, unsigned long addr_only)
3046 {
3047         int rc = 0;
3048         u32 sid = current_sid();
3049
3050         /*
3051          * notice that we are intentionally putting the SELinux check before
3052          * the secondary cap_file_mmap check.  This is such a likely attempt
3053          * at bad behaviour/exploit that we always want to get the AVC, even
3054          * if DAC would have also denied the operation.
3055          */
3056         if (addr < CONFIG_LSM_MMAP_MIN_ADDR) {
3057                 rc = avc_has_perm(sid, sid, SECCLASS_MEMPROTECT,
3058                                   MEMPROTECT__MMAP_ZERO, NULL);
3059                 if (rc)
3060                         return rc;
3061         }
3062
3063         /* do DAC check on address space usage */
3064         rc = cap_file_mmap(file, reqprot, prot, flags, addr, addr_only);
3065         if (rc || addr_only)
3066                 return rc;
3067
3068         if (selinux_checkreqprot)
3069                 prot = reqprot;
3070
3071         return file_map_prot_check(file, prot,
3072                                    (flags & MAP_TYPE) == MAP_SHARED);
3073 }
3074
3075 static int selinux_file_mprotect(struct vm_area_struct *vma,
3076                                  unsigned long reqprot,
3077                                  unsigned long prot)
3078 {
3079         const struct cred *cred = current_cred();
3080
3081         if (selinux_checkreqprot)
3082                 prot = reqprot;
3083
3084         if (default_noexec &&
3085             (prot & PROT_EXEC) && !(vma->vm_flags & VM_EXEC)) {
3086                 int rc = 0;
3087                 if (vma->vm_start >= vma->vm_mm->start_brk &&
3088                     vma->vm_end <= vma->vm_mm->brk) {
3089                         rc = cred_has_perm(cred, cred, PROCESS__EXECHEAP);
3090                 } else if (!vma->vm_file &&
3091                            vma->vm_start <= vma->vm_mm->start_stack &&
3092                            vma->vm_end >= vma->vm_mm->start_stack) {
3093                         rc = current_has_perm(current, PROCESS__EXECSTACK);
3094                 } else if (vma->vm_file && vma->anon_vma) {
3095                         /*
3096                          * We are making executable a file mapping that has
3097                          * had some COW done. Since pages might have been
3098                          * written, check ability to execute the possibly
3099                          * modified content.  This typically should only
3100                          * occur for text relocations.
3101                          */
3102                         rc = file_has_perm(cred, vma->vm_file, FILE__EXECMOD);
3103                 }
3104                 if (rc)
3105                         return rc;
3106         }
3107
3108         return file_map_prot_check(vma->vm_file, prot, vma->vm_flags&VM_SHARED);
3109 }
3110
3111 static int selinux_file_lock(struct file *file, unsigned int cmd)
3112 {
3113         const struct cred *cred = current_cred();
3114
3115         return file_has_perm(cred, file, FILE__LOCK);
3116 }
3117
3118 static int selinux_file_fcntl(struct file *file, unsigned int cmd,
3119                               unsigned long arg)
3120 {
3121         const struct cred *cred = current_cred();
3122         int err = 0;
3123
3124         switch (cmd) {
3125         case F_SETFL:
3126                 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3127                         err = -EINVAL;
3128                         break;
3129                 }
3130
3131                 if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) {
3132                         err = file_has_perm(cred, file, FILE__WRITE);
3133                         break;
3134                 }
3135                 /* fall through */
3136         case F_SETOWN:
3137         case F_SETSIG:
3138         case F_GETFL:
3139         case F_GETOWN:
3140         case F_GETSIG:
3141                 /* Just check FD__USE permission */
3142                 err = file_has_perm(cred, file, 0);
3143                 break;
3144         case F_GETLK:
3145         case F_SETLK:
3146         case F_SETLKW:
3147 #if BITS_PER_LONG == 32
3148         case F_GETLK64:
3149         case F_SETLK64:
3150         case F_SETLKW64:
3151 #endif
3152                 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3153                         err = -EINVAL;
3154                         break;
3155                 }
3156                 err = file_has_perm(cred, file, FILE__LOCK);
3157                 break;
3158         }
3159
3160         return err;
3161 }
3162
3163 static int selinux_file_set_fowner(struct file *file)
3164 {
3165         struct file_security_struct *fsec;
3166
3167         fsec = file->f_security;
3168         fsec->fown_sid = current_sid();
3169
3170         return 0;
3171 }
3172
3173 static int selinux_file_send_sigiotask(struct task_struct *tsk,
3174                                        struct fown_struct *fown, int signum)
3175 {
3176         struct file *file;
3177         u32 sid = task_sid(tsk);
3178         u32 perm;
3179         struct file_security_struct *fsec;
3180
3181         /* struct fown_struct is never outside the context of a struct file */
3182         file = container_of(fown, struct file, f_owner);
3183
3184         fsec = file->f_security;
3185
3186         if (!signum)
3187                 perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */
3188         else
3189                 perm = signal_to_av(signum);
3190
3191         return avc_has_perm(fsec->fown_sid, sid,
3192                             SECCLASS_PROCESS, perm, NULL);
3193 }
3194
3195 static int selinux_file_receive(struct file *file)
3196 {
3197         const struct cred *cred = current_cred();
3198
3199         return file_has_perm(cred, file, file_to_av(file));
3200 }
3201
3202 static int selinux_dentry_open(struct file *file, const struct cred *cred)
3203 {
3204         struct file_security_struct *fsec;
3205         struct inode *inode;
3206         struct inode_security_struct *isec;
3207
3208         inode = file->f_path.dentry->d_inode;
3209         fsec = file->f_security;
3210         isec = inode->i_security;
3211         /*
3212          * Save inode label and policy sequence number
3213          * at open-time so that selinux_file_permission
3214          * can determine whether revalidation is necessary.
3215          * Task label is already saved in the file security
3216          * struct as its SID.
3217          */
3218         fsec->isid = isec->sid;
3219         fsec->pseqno = avc_policy_seqno();
3220         /*
3221          * Since the inode label or policy seqno may have changed
3222          * between the selinux_inode_permission check and the saving
3223          * of state above, recheck that access is still permitted.
3224          * Otherwise, access might never be revalidated against the
3225          * new inode label or new policy.
3226          * This check is not redundant - do not remove.
3227          */
3228         return inode_has_perm(cred, inode, open_file_to_av(file), NULL, 0);
3229 }
3230
3231 /* task security operations */
3232
3233 static int selinux_task_create(unsigned long clone_flags)
3234 {
3235         return current_has_perm(current, PROCESS__FORK);
3236 }
3237
3238 /*
3239  * allocate the SELinux part of blank credentials
3240  */
3241 static int selinux_cred_alloc_blank(struct cred *cred, gfp_t gfp)
3242 {
3243         struct task_security_struct *tsec;
3244
3245         tsec = kzalloc(sizeof(struct task_security_struct), gfp);
3246         if (!tsec)
3247                 return -ENOMEM;
3248
3249         cred->security = tsec;
3250         return 0;
3251 }
3252
3253 /*
3254  * detach and free the LSM part of a set of credentials
3255  */
3256 static void selinux_cred_free(struct cred *cred)
3257 {
3258         struct task_security_struct *tsec = cred->security;
3259
3260         /*
3261          * cred->security == NULL if security_cred_alloc_blank() or
3262          * security_prepare_creds() returned an error.
3263          */
3264         BUG_ON(cred->security && (unsigned long) cred->security < PAGE_SIZE);
3265         cred->security = (void *) 0x7UL;
3266         kfree(tsec);
3267 }
3268
3269 /*
3270  * prepare a new set of credentials for modification
3271  */
3272 static int selinux_cred_prepare(struct cred *new, const struct cred *old,
3273                                 gfp_t gfp)
3274 {
3275         const struct task_security_struct *old_tsec;
3276         struct task_security_struct *tsec;
3277
3278         old_tsec = old->security;
3279
3280         tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp);
3281         if (!tsec)
3282                 return -ENOMEM;
3283
3284         new->security = tsec;
3285         return 0;
3286 }
3287
3288 /*
3289  * transfer the SELinux data to a blank set of creds
3290  */
3291 static void selinux_cred_transfer(struct cred *new, const struct cred *old)
3292 {
3293         const struct task_security_struct *old_tsec = old->security;
3294         struct task_security_struct *tsec = new->security;
3295
3296         *tsec = *old_tsec;
3297 }
3298
3299 /*
3300  * set the security data for a kernel service
3301  * - all the creation contexts are set to unlabelled
3302  */
3303 static int selinux_kernel_act_as(struct cred *new, u32 secid)
3304 {
3305         struct task_security_struct *tsec = new->security;
3306         u32 sid = current_sid();
3307         int ret;
3308
3309         ret = avc_has_perm(sid, secid,
3310                            SECCLASS_KERNEL_SERVICE,
3311                            KERNEL_SERVICE__USE_AS_OVERRIDE,
3312                            NULL);
3313         if (ret == 0) {
3314                 tsec->sid = secid;
3315                 tsec->create_sid = 0;
3316                 tsec->keycreate_sid = 0;
3317                 tsec->sockcreate_sid = 0;
3318         }
3319         return ret;
3320 }
3321
3322 /*
3323  * set the file creation context in a security record to the same as the
3324  * objective context of the specified inode
3325  */
3326 static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
3327 {
3328         struct inode_security_struct *isec = inode->i_security;
3329         struct task_security_struct *tsec = new->security;
3330         u32 sid = current_sid();
3331         int ret;
3332
3333         ret = avc_has_perm(sid, isec->sid,
3334                            SECCLASS_KERNEL_SERVICE,
3335                            KERNEL_SERVICE__CREATE_FILES_AS,
3336                            NULL);
3337
3338         if (ret == 0)
3339                 tsec->create_sid = isec->sid;
3340         return ret;
3341 }
3342
3343 static int selinux_kernel_module_request(char *kmod_name)
3344 {
3345         u32 sid;
3346         struct common_audit_data ad;
3347
3348         sid = task_sid(current);
3349
3350         COMMON_AUDIT_DATA_INIT(&ad, KMOD);
3351         ad.u.kmod_name = kmod_name;
3352
3353         return avc_has_perm(sid, SECINITSID_KERNEL, SECCLASS_SYSTEM,
3354                             SYSTEM__MODULE_REQUEST, &ad);
3355 }
3356
3357 static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
3358 {
3359         return current_has_perm(p, PROCESS__SETPGID);
3360 }
3361
3362 static int selinux_task_getpgid(struct task_struct *p)
3363 {
3364         return current_has_perm(p, PROCESS__GETPGID);
3365 }
3366
3367 static int selinux_task_getsid(struct task_struct *p)
3368 {
3369         return current_has_perm(p, PROCESS__GETSESSION);
3370 }
3371
3372 static void selinux_task_getsecid(struct task_struct *p, u32 *secid)
3373 {
3374         *secid = task_sid(p);
3375 }
3376
3377 static int selinux_task_setnice(struct task_struct *p, int nice)
3378 {
3379         int rc;
3380
3381         rc = cap_task_setnice(p, nice);
3382         if (rc)
3383                 return rc;
3384
3385         return current_has_perm(p, PROCESS__SETSCHED);
3386 }
3387
3388 static int selinux_task_setioprio(struct task_struct *p, int ioprio)
3389 {
3390         int rc;
3391
3392         rc = cap_task_setioprio(p, ioprio);
3393         if (rc)
3394                 return rc;
3395
3396         return current_has_perm(p, PROCESS__SETSCHED);
3397 }
3398
3399 static int selinux_task_getioprio(struct task_struct *p)
3400 {
3401         return current_has_perm(p, PROCESS__GETSCHED);
3402 }
3403
3404 static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource,
3405                 struct rlimit *new_rlim)
3406 {
3407         struct rlimit *old_rlim = p->signal->rlim + resource;
3408
3409         /* Control the ability to change the hard limit (whether
3410            lowering or raising it), so that the hard limit can
3411            later be used as a safe reset point for the soft limit
3412            upon context transitions.  See selinux_bprm_committing_creds. */
3413         if (old_rlim->rlim_max != new_rlim->rlim_max)
3414                 return current_has_perm(p, PROCESS__SETRLIMIT);
3415
3416         return 0;
3417 }
3418
3419 static int selinux_task_setscheduler(struct task_struct *p)
3420 {
3421         int rc;
3422
3423         rc = cap_task_setscheduler(p);
3424         if (rc)
3425                 return rc;
3426
3427         return current_has_perm(p, PROCESS__SETSCHED);
3428 }
3429
3430 static int selinux_task_getscheduler(struct task_struct *p)
3431 {
3432         return current_has_perm(p, PROCESS__GETSCHED);
3433 }
3434
3435 static int selinux_task_movememory(struct task_struct *p)
3436 {
3437         return current_has_perm(p, PROCESS__SETSCHED);
3438 }
3439
3440 static int selinux_task_kill(struct task_struct *p, struct siginfo *info,
3441                                 int sig, u32 secid)
3442 {
3443         u32 perm;
3444         int rc;
3445
3446         if (!sig)
3447                 perm = PROCESS__SIGNULL; /* null signal; existence test */
3448         else
3449                 perm = signal_to_av(sig);
3450         if (secid)
3451                 rc = avc_has_perm(secid, task_sid(p),
3452                                   SECCLASS_PROCESS, perm, NULL);
3453         else
3454                 rc = current_has_perm(p, perm);
3455         return rc;
3456 }
3457
3458 static int selinux_task_wait(struct task_struct *p)
3459 {
3460         return task_has_perm(p, current, PROCESS__SIGCHLD);
3461 }
3462
3463 static void selinux_task_to_inode(struct task_struct *p,
3464                                   struct inode *inode)
3465 {
3466         struct inode_security_struct *isec = inode->i_security;
3467         u32 sid = task_sid(p);
3468
3469         isec->sid = sid;
3470         isec->initialized = 1;
3471 }
3472
3473 /* Returns error only if unable to parse addresses */
3474 static int selinux_parse_skb_ipv4(struct sk_buff *skb,
3475                         struct common_audit_data *ad, u8 *proto)
3476 {
3477         int offset, ihlen, ret = -EINVAL;
3478         struct iphdr _iph, *ih;
3479
3480         offset = skb_network_offset(skb);
3481         ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
3482         if (ih == NULL)
3483                 goto out;
3484
3485         ihlen = ih->ihl * 4;
3486         if (ihlen < sizeof(_iph))
3487                 goto out;
3488
3489         ad->u.net.v4info.saddr = ih->saddr;
3490         ad->u.net.v4info.daddr = ih->daddr;
3491         ret = 0;
3492
3493         if (proto)
3494                 *proto = ih->protocol;
3495
3496         switch (ih->protocol) {
3497         case IPPROTO_TCP: {
3498                 struct tcphdr _tcph, *th;
3499
3500                 if (ntohs(ih->frag_off) & IP_OFFSET)
3501                         break;
3502
3503                 offset += ihlen;
3504                 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3505                 if (th == NULL)
3506                         break;
3507
3508                 ad->u.net.sport = th->source;
3509                 ad->u.net.dport = th->dest;
3510                 break;
3511         }
3512
3513         case IPPROTO_UDP: {
3514                 struct udphdr _udph, *uh;
3515
3516                 if (ntohs(ih->frag_off) & IP_OFFSET)
3517                         break;
3518
3519                 offset += ihlen;
3520                 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3521                 if (uh == NULL)
3522                         break;
3523
3524                 ad->u.net.sport = uh->source;
3525                 ad->u.net.dport = uh->dest;
3526                 break;
3527         }
3528
3529         case IPPROTO_DCCP: {
3530                 struct dccp_hdr _dccph, *dh;
3531
3532                 if (ntohs(ih->frag_off) & IP_OFFSET)
3533                         break;
3534
3535                 offset += ihlen;
3536                 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3537                 if (dh == NULL)
3538                         break;
3539
3540                 ad->u.net.sport = dh->dccph_sport;
3541                 ad->u.net.dport = dh->dccph_dport;
3542                 break;
3543         }
3544
3545         default:
3546                 break;
3547         }
3548 out:
3549         return ret;
3550 }
3551
3552 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3553
3554 /* Returns error only if unable to parse addresses */
3555 static int selinux_parse_skb_ipv6(struct sk_buff *skb,
3556                         struct common_audit_data *ad, u8 *proto)
3557 {
3558         u8 nexthdr;
3559         int ret = -EINVAL, offset;
3560         struct ipv6hdr _ipv6h, *ip6;
3561
3562         offset = skb_network_offset(skb);
3563         ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3564         if (ip6 == NULL)
3565                 goto out;
3566
3567         ipv6_addr_copy(&ad->u.net.v6info.saddr, &ip6->saddr);
3568         ipv6_addr_copy(&ad->u.net.v6info.daddr, &ip6->daddr);
3569         ret = 0;
3570
3571         nexthdr = ip6->nexthdr;
3572         offset += sizeof(_ipv6h);
3573         offset = ipv6_skip_exthdr(skb, offset, &nexthdr);
3574         if (offset < 0)
3575                 goto out;
3576
3577         if (proto)
3578                 *proto = nexthdr;
3579
3580         switch (nexthdr) {
3581         case IPPROTO_TCP: {
3582                 struct tcphdr _tcph, *th;
3583
3584                 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3585                 if (th == NULL)
3586                         break;
3587
3588                 ad->u.net.sport = th->source;
3589                 ad->u.net.dport = th->dest;
3590                 break;
3591         }
3592
3593         case IPPROTO_UDP: {
3594                 struct udphdr _udph, *uh;
3595
3596                 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3597                 if (uh == NULL)
3598                         break;
3599
3600                 ad->u.net.sport = uh->source;
3601                 ad->u.net.dport = uh->dest;
3602                 break;
3603         }
3604
3605         case IPPROTO_DCCP: {
3606                 struct dccp_hdr _dccph, *dh;
3607
3608                 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3609                 if (dh == NULL)
3610                         break;
3611
3612                 ad->u.net.sport = dh->dccph_sport;
3613                 ad->u.net.dport = dh->dccph_dport;
3614                 break;
3615         }
3616
3617         /* includes fragments */
3618         default:
3619                 break;
3620         }
3621 out:
3622         return ret;
3623 }
3624
3625 #endif /* IPV6 */
3626
3627 static int selinux_parse_skb(struct sk_buff *skb, struct common_audit_data *ad,
3628                              char **_addrp, int src, u8 *proto)
3629 {
3630         char *addrp;
3631         int ret;
3632
3633         switch (ad->u.net.family) {
3634         case PF_INET:
3635                 ret = selinux_parse_skb_ipv4(skb, ad, proto);
3636                 if (ret)
3637                         goto parse_error;
3638                 addrp = (char *)(src ? &ad->u.net.v4info.saddr :
3639                                        &ad->u.net.v4info.daddr);
3640                 goto okay;
3641
3642 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3643         case PF_INET6:
3644                 ret = selinux_parse_skb_ipv6(skb, ad, proto);
3645                 if (ret)
3646                         goto parse_error;
3647                 addrp = (char *)(src ? &ad->u.net.v6info.saddr :
3648                                        &ad->u.net.v6info.daddr);
3649                 goto okay;
3650 #endif  /* IPV6 */
3651         default:
3652                 addrp = NULL;
3653                 goto okay;
3654         }
3655
3656 parse_error:
3657         printk(KERN_WARNING
3658                "SELinux: failure in selinux_parse_skb(),"
3659                " unable to parse packet\n");
3660         return ret;
3661
3662 okay:
3663         if (_addrp)
3664                 *_addrp = addrp;
3665         return 0;
3666 }
3667
3668 /**
3669  * selinux_skb_peerlbl_sid - Determine the peer label of a packet
3670  * @skb: the packet
3671  * @family: protocol family
3672  * @sid: the packet's peer label SID
3673  *
3674  * Description:
3675  * Check the various different forms of network peer labeling and determine
3676  * the peer label/SID for the packet; most of the magic actually occurs in
3677  * the security server function security_net_peersid_cmp().  The function
3678  * returns zero if the value in @sid is valid (although it may be SECSID_NULL)
3679  * or -EACCES if @sid is invalid due to inconsistencies with the different
3680  * peer labels.
3681  *
3682  */
3683 static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid)
3684 {
3685         int err;
3686         u32 xfrm_sid;
3687         u32 nlbl_sid;
3688         u32 nlbl_type;
3689
3690         selinux_skb_xfrm_sid(skb, &xfrm_sid);
3691         selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
3692
3693         err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid);
3694         if (unlikely(err)) {
3695                 printk(KERN_WARNING
3696                        "SELinux: failure in selinux_skb_peerlbl_sid(),"
3697                        " unable to determine packet's peer label\n");
3698                 return -EACCES;
3699         }
3700
3701         return 0;
3702 }
3703
3704 /* socket security operations */
3705
3706 static int socket_sockcreate_sid(const struct task_security_struct *tsec,
3707                                  u16 secclass, u32 *socksid)
3708 {
3709         if (tsec->sockcreate_sid > SECSID_NULL) {
3710                 *socksid = tsec->sockcreate_sid;
3711                 return 0;
3712         }
3713
3714         return security_transition_sid(tsec->sid, tsec->sid, secclass, NULL,
3715                                        socksid);
3716 }
3717
3718 static int sock_has_perm(struct task_struct *task, struct sock *sk, u32 perms)
3719 {
3720         struct sk_security_struct *sksec = sk->sk_security;
3721         struct common_audit_data ad;
3722         u32 tsid = task_sid(task);
3723
3724         if (sksec->sid == SECINITSID_KERNEL)
3725                 return 0;
3726
3727         COMMON_AUDIT_DATA_INIT(&ad, NET);
3728         ad.u.net.sk = sk;
3729
3730         return avc_has_perm(tsid, sksec->sid, sksec->sclass, perms, &ad);
3731 }
3732
3733 static int selinux_socket_create(int family, int type,
3734                                  int protocol, int kern)
3735 {
3736         const struct task_security_struct *tsec = current_security();
3737         u32 newsid;
3738         u16 secclass;
3739         int rc;
3740
3741         if (kern)
3742                 return 0;
3743
3744         secclass = socket_type_to_security_class(family, type, protocol);
3745         rc = socket_sockcreate_sid(tsec, secclass, &newsid);
3746         if (rc)
3747                 return rc;
3748
3749         return avc_has_perm(tsec->sid, newsid, secclass, SOCKET__CREATE, NULL);
3750 }
3751
3752 static int selinux_socket_post_create(struct socket *sock, int family,
3753                                       int type, int protocol, int kern)
3754 {
3755         const struct task_security_struct *tsec = current_security();
3756         struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
3757         struct sk_security_struct *sksec;
3758         int err = 0;
3759
3760         isec->sclass = socket_type_to_security_class(family, type, protocol);
3761
3762         if (kern)
3763                 isec->sid = SECINITSID_KERNEL;
3764         else {
3765                 err = socket_sockcreate_sid(tsec, isec->sclass, &(isec->sid));
3766                 if (err)
3767                         return err;
3768         }
3769
3770         isec->initialized = 1;
3771
3772         if (sock->sk) {
3773                 sksec = sock->sk->sk_security;
3774                 sksec->sid = isec->sid;
3775                 sksec->sclass = isec->sclass;
3776                 err = selinux_netlbl_socket_post_create(sock->sk, family);
3777         }
3778
3779         return err;
3780 }
3781
3782 /* Range of port numbers used to automatically bind.
3783    Need to determine whether we should perform a name_bind
3784    permission check between the socket and the port number. */
3785
3786 static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
3787 {
3788         struct sock *sk = sock->sk;
3789         u16 family;
3790         int err;
3791
3792         err = sock_has_perm(current, sk, SOCKET__BIND);
3793         if (err)
3794                 goto out;
3795
3796         /*
3797          * If PF_INET or PF_INET6, check name_bind permission for the port.
3798          * Multiple address binding for SCTP is not supported yet: we just
3799          * check the first address now.
3800          */
3801         family = sk->sk_family;
3802         if (family == PF_INET || family == PF_INET6) {
3803                 char *addrp;
3804                 struct sk_security_struct *sksec = sk->sk_security;
3805                 struct common_audit_data ad;
3806                 struct sockaddr_in *addr4 = NULL;
3807                 struct sockaddr_in6 *addr6 = NULL;
3808                 unsigned short snum;
3809                 u32 sid, node_perm;
3810
3811                 if (family == PF_INET) {
3812                         addr4 = (struct sockaddr_in *)address;
3813                         snum = ntohs(addr4->sin_port);
3814                         addrp = (char *)&addr4->sin_addr.s_addr;
3815                 } else {
3816                         addr6 = (struct sockaddr_in6 *)address;
3817                         snum = ntohs(addr6->sin6_port);
3818                         addrp = (char *)&addr6->sin6_addr.s6_addr;
3819                 }
3820
3821                 if (snum) {
3822                         int low, high;
3823
3824                         inet_get_local_port_range(&low, &high);
3825
3826                         if (snum < max(PROT_SOCK, low) || snum > high) {
3827                                 err = sel_netport_sid(sk->sk_protocol,
3828                                                       snum, &sid);
3829                                 if (err)
3830                                         goto out;
3831                                 COMMON_AUDIT_DATA_INIT(&ad, NET);
3832                                 ad.u.net.sport = htons(snum);
3833                                 ad.u.net.family = family;
3834                                 err = avc_has_perm(sksec->sid, sid,
3835                                                    sksec->sclass,
3836                                                    SOCKET__NAME_BIND, &ad);
3837                                 if (err)
3838                                         goto out;
3839                         }
3840                 }
3841
3842                 switch (sksec->sclass) {
3843                 case SECCLASS_TCP_SOCKET:
3844                         node_perm = TCP_SOCKET__NODE_BIND;
3845                         break;
3846
3847                 case SECCLASS_UDP_SOCKET:
3848                         node_perm = UDP_SOCKET__NODE_BIND;
3849                         break;
3850
3851                 case SECCLASS_DCCP_SOCKET:
3852                         node_perm = DCCP_SOCKET__NODE_BIND;
3853                         break;
3854
3855                 default:
3856                         node_perm = RAWIP_SOCKET__NODE_BIND;
3857                         break;
3858                 }
3859
3860                 err = sel_netnode_sid(addrp, family, &sid);
3861                 if (err)
3862                         goto out;
3863
3864                 COMMON_AUDIT_DATA_INIT(&ad, NET);
3865                 ad.u.net.sport = htons(snum);
3866                 ad.u.net.family = family;
3867
3868                 if (family == PF_INET)
3869                         ad.u.net.v4info.saddr = addr4->sin_addr.s_addr;
3870                 else
3871                         ipv6_addr_copy(&ad.u.net.v6info.saddr, &addr6->sin6_addr);
3872
3873                 err = avc_has_perm(sksec->sid, sid,
3874                                    sksec->sclass, node_perm, &ad);
3875                 if (err)
3876                         goto out;
3877         }
3878 out:
3879         return err;
3880 }
3881
3882 static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
3883 {
3884         struct sock *sk = sock->sk;
3885         struct sk_security_struct *sksec = sk->sk_security;
3886         int err;
3887
3888         err = sock_has_perm(current, sk, SOCKET__CONNECT);
3889         if (err)
3890                 return err;
3891
3892         /*
3893          * If a TCP or DCCP socket, check name_connect permission for the port.
3894          */
3895         if (sksec->sclass == SECCLASS_TCP_SOCKET ||
3896             sksec->sclass == SECCLASS_DCCP_SOCKET) {
3897                 struct common_audit_data ad;
3898                 struct sockaddr_in *addr4 = NULL;
3899                 struct sockaddr_in6 *addr6 = NULL;
3900                 unsigned short snum;
3901                 u32 sid, perm;
3902
3903                 if (sk->sk_family == PF_INET) {
3904                         addr4 = (struct sockaddr_in *)address;
3905                         if (addrlen < sizeof(struct sockaddr_in))
3906                                 return -EINVAL;
3907                         snum = ntohs(addr4->sin_port);
3908                 } else {
3909                         addr6 = (struct sockaddr_in6 *)address;
3910                         if (addrlen < SIN6_LEN_RFC2133)
3911                                 return -EINVAL;
3912                         snum = ntohs(addr6->sin6_port);
3913                 }
3914
3915                 err = sel_netport_sid(sk->sk_protocol, snum, &sid);
3916                 if (err)
3917                         goto out;
3918
3919                 perm = (sksec->sclass == SECCLASS_TCP_SOCKET) ?
3920                        TCP_SOCKET__NAME_CONNECT : DCCP_SOCKET__NAME_CONNECT;
3921
3922                 COMMON_AUDIT_DATA_INIT(&ad, NET);
3923                 ad.u.net.dport = htons(snum);
3924                 ad.u.net.family = sk->sk_family;
3925                 err = avc_has_perm(sksec->sid, sid, sksec->sclass, perm, &ad);
3926                 if (err)
3927                         goto out;
3928         }
3929
3930         err = selinux_netlbl_socket_connect(sk, address);
3931
3932 out:
3933         return err;
3934 }
3935
3936 static int selinux_socket_listen(struct socket *sock, int backlog)
3937 {
3938         return sock_has_perm(current, sock->sk, SOCKET__LISTEN);
3939 }
3940
3941 static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
3942 {
3943         int err;
3944         struct inode_security_struct *isec;
3945         struct inode_security_struct *newisec;
3946
3947         err = sock_has_perm(current, sock->sk, SOCKET__ACCEPT);
3948         if (err)
3949                 return err;
3950
3951         newisec = SOCK_INODE(newsock)->i_security;
3952
3953         isec = SOCK_INODE(sock)->i_security;
3954         newisec->sclass = isec->sclass;
3955         newisec->sid = isec->sid;
3956         newisec->initialized = 1;
3957
3958         return 0;
3959 }
3960
3961 static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
3962                                   int size)
3963 {
3964         return sock_has_perm(current, sock->sk, SOCKET__WRITE);
3965 }
3966
3967 static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
3968                                   int size, int flags)
3969 {
3970         return sock_has_perm(current, sock->sk, SOCKET__READ);
3971 }
3972
3973 static int selinux_socket_getsockname(struct socket *sock)
3974 {
3975         return sock_has_perm(current, sock->sk, SOCKET__GETATTR);
3976 }
3977
3978 static int selinux_socket_getpeername(struct socket *sock)
3979 {
3980         return sock_has_perm(current, sock->sk, SOCKET__GETATTR);
3981 }
3982
3983 static int selinux_socket_setsockopt(struct socket *sock, int level, int optname)
3984 {
3985         int err;
3986
3987         err = sock_has_perm(current, sock->sk, SOCKET__SETOPT);
3988         if (err)
3989                 return err;
3990
3991         return selinux_netlbl_socket_setsockopt(sock, level, optname);
3992 }
3993
3994 static int selinux_socket_getsockopt(struct socket *sock, int level,
3995                                      int optname)
3996 {
3997         return sock_has_perm(current, sock->sk, SOCKET__GETOPT);
3998 }
3999
4000 static int selinux_socket_shutdown(struct socket *sock, int how)
4001 {
4002         return sock_has_perm(current, sock->sk, SOCKET__SHUTDOWN);
4003 }
4004
4005 static int selinux_socket_unix_stream_connect(struct sock *sock,
4006                                               struct sock *other,
4007                                               struct sock *newsk)
4008 {
4009         struct sk_security_struct *sksec_sock = sock->sk_security;
4010         struct sk_security_struct *sksec_other = other->sk_security;
4011         struct sk_security_struct *sksec_new = newsk->sk_security;
4012         struct common_audit_data ad;
4013         int err;
4014
4015         COMMON_AUDIT_DATA_INIT(&ad, NET);
4016         ad.u.net.sk = other;
4017
4018         err = avc_has_perm(sksec_sock->sid, sksec_other->sid,
4019                            sksec_other->sclass,
4020                            UNIX_STREAM_SOCKET__CONNECTTO, &ad);
4021         if (err)
4022                 return err;
4023
4024         /* server child socket */
4025         sksec_new->peer_sid = sksec_sock->sid;
4026         err = security_sid_mls_copy(sksec_other->sid, sksec_sock->sid,
4027                                     &sksec_new->sid);
4028         if (err)
4029                 return err;
4030
4031         /* connecting socket */
4032         sksec_sock->peer_sid = sksec_new->sid;
4033
4034         return 0;
4035 }
4036
4037 static int selinux_socket_unix_may_send(struct socket *sock,
4038                                         struct socket *other)
4039 {
4040         struct sk_security_struct *ssec = sock->sk->sk_security;
4041         struct sk_security_struct *osec = other->sk->sk_security;
4042         struct common_audit_data ad;
4043
4044         COMMON_AUDIT_DATA_INIT(&ad, NET);
4045         ad.u.net.sk = other->sk;
4046
4047         return avc_has_perm(ssec->sid, osec->sid, osec->sclass, SOCKET__SENDTO,
4048                             &ad);
4049 }
4050
4051 static int selinux_inet_sys_rcv_skb(int ifindex, char *addrp, u16 family,
4052                                     u32 peer_sid,
4053                                     struct common_audit_data *ad)
4054 {
4055         int err;
4056         u32 if_sid;
4057         u32 node_sid;
4058
4059         err = sel_netif_sid(ifindex, &if_sid);
4060         if (err)
4061                 return err;
4062         err = avc_has_perm(peer_sid, if_sid,
4063                            SECCLASS_NETIF, NETIF__INGRESS, ad);
4064         if (err)
4065                 return err;
4066
4067         err = sel_netnode_sid(addrp, family, &node_sid);
4068         if (err)
4069                 return err;
4070         return avc_has_perm(peer_sid, node_sid,
4071                             SECCLASS_NODE, NODE__RECVFROM, ad);
4072 }
4073
4074 static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
4075                                        u16 family)
4076 {
4077         int err = 0;
4078         struct sk_security_struct *sksec = sk->sk_security;
4079         u32 sk_sid = sksec->sid;
4080         struct common_audit_data ad;
4081         char *addrp;
4082
4083         COMMON_AUDIT_DATA_INIT(&ad, NET);
4084         ad.u.net.netif = skb->skb_iif;
4085         ad.u.net.family = family;
4086         err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4087         if (err)
4088                 return err;
4089
4090         if (selinux_secmark_enabled()) {
4091                 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4092                                    PACKET__RECV, &ad);
4093                 if (err)
4094                         return err;
4095         }
4096
4097         err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad);
4098         if (err)
4099                 return err;
4100         err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
4101
4102         return err;
4103 }
4104
4105 static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
4106 {
4107         int err;
4108         struct sk_security_struct *sksec = sk->sk_security;
4109         u16 family = sk->sk_family;
4110         u32 sk_sid = sksec->sid;
4111         struct common_audit_data ad;
4112         char *addrp;
4113         u8 secmark_active;
4114         u8 peerlbl_active;
4115
4116         if (family != PF_INET && family != PF_INET6)
4117                 return 0;
4118
4119         /* Handle mapped IPv4 packets arriving via IPv6 sockets */
4120         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4121                 family = PF_INET;
4122
4123         /* If any sort of compatibility mode is enabled then handoff processing
4124          * to the selinux_sock_rcv_skb_compat() function to deal with the
4125          * special handling.  We do this in an attempt to keep this function
4126          * as fast and as clean as possible. */
4127         if (!selinux_policycap_netpeer)
4128                 return selinux_sock_rcv_skb_compat(sk, skb, family);
4129
4130         secmark_active = selinux_secmark_enabled();
4131         peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4132         if (!secmark_active && !peerlbl_active)
4133                 return 0;
4134
4135         COMMON_AUDIT_DATA_INIT(&ad, NET);
4136         ad.u.net.netif = skb->skb_iif;
4137         ad.u.net.family = family;
4138         err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4139         if (err)
4140                 return err;
4141
4142         if (peerlbl_active) {
4143                 u32 peer_sid;
4144
4145                 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
4146                 if (err)
4147                         return err;
4148                 err = selinux_inet_sys_rcv_skb(skb->skb_iif, addrp, family,
4149                                                peer_sid, &ad);
4150                 if (err) {
4151                         selinux_netlbl_err(skb, err, 0);
4152                         return err;
4153                 }
4154                 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
4155                                    PEER__RECV, &ad);
4156                 if (err)
4157                         selinux_netlbl_err(skb, err, 0);
4158         }
4159
4160         if (secmark_active) {
4161                 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4162                                    PACKET__RECV, &ad);
4163                 if (err)
4164                         return err;
4165         }
4166
4167         return err;
4168 }
4169
4170 static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *optval,
4171                                             int __user *optlen, unsigned len)
4172 {
4173         int err = 0;
4174         char *scontext;
4175         u32 scontext_len;
4176         struct sk_security_struct *sksec = sock->sk->sk_security;
4177         u32 peer_sid = SECSID_NULL;
4178
4179         if (sksec->sclass == SECCLASS_UNIX_STREAM_SOCKET ||
4180             sksec->sclass == SECCLASS_TCP_SOCKET)
4181                 peer_sid = sksec->peer_sid;
4182         if (peer_sid == SECSID_NULL)
4183                 return -ENOPROTOOPT;
4184
4185         err = security_sid_to_context(peer_sid, &scontext, &scontext_len);
4186         if (err)
4187                 return err;
4188
4189         if (scontext_len > len) {
4190                 err = -ERANGE;
4191                 goto out_len;
4192         }
4193
4194         if (copy_to_user(optval, scontext, scontext_len))
4195                 err = -EFAULT;
4196
4197 out_len:
4198         if (put_user(scontext_len, optlen))
4199                 err = -EFAULT;
4200         kfree(scontext);
4201         return err;
4202 }
4203
4204 static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
4205 {
4206         u32 peer_secid = SECSID_NULL;
4207         u16 family;
4208
4209         if (skb && skb->protocol == htons(ETH_P_IP))
4210                 family = PF_INET;
4211         else if (skb && skb->protocol == htons(ETH_P_IPV6))
4212                 family = PF_INET6;
4213         else if (sock)
4214                 family = sock->sk->sk_family;
4215         else
4216                 goto out;
4217
4218         if (sock && family == PF_UNIX)
4219                 selinux_inode_getsecid(SOCK_INODE(sock), &peer_secid);
4220         else if (skb)
4221                 selinux_skb_peerlbl_sid(skb, family, &peer_secid);
4222
4223 out:
4224         *secid = peer_secid;
4225         if (peer_secid == SECSID_NULL)
4226                 return -EINVAL;
4227         return 0;
4228 }
4229
4230 static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority)
4231 {
4232         struct sk_security_struct *sksec;
4233
4234         sksec = kzalloc(sizeof(*sksec), priority);
4235         if (!sksec)
4236                 return -ENOMEM;
4237
4238         sksec->peer_sid = SECINITSID_UNLABELED;
4239         sksec->sid = SECINITSID_UNLABELED;
4240         selinux_netlbl_sk_security_reset(sksec);
4241         sk->sk_security = sksec;
4242
4243         return 0;
4244 }
4245
4246 static void selinux_sk_free_security(struct sock *sk)
4247 {
4248         struct sk_security_struct *sksec = sk->sk_security;
4249
4250         sk->sk_security = NULL;
4251         selinux_netlbl_sk_security_free(sksec);
4252         kfree(sksec);
4253 }
4254
4255 static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
4256 {
4257         struct sk_security_struct *sksec = sk->sk_security;
4258         struct sk_security_struct *newsksec = newsk->sk_security;
4259
4260         newsksec->sid = sksec->sid;
4261         newsksec->peer_sid = sksec->peer_sid;
4262         newsksec->sclass = sksec->sclass;
4263
4264         selinux_netlbl_sk_security_reset(newsksec);
4265 }
4266
4267 static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
4268 {
4269         if (!sk)
4270                 *secid = SECINITSID_ANY_SOCKET;
4271         else {
4272                 struct sk_security_struct *sksec = sk->sk_security;
4273
4274                 *secid = sksec->sid;
4275         }
4276 }
4277
4278 static void selinux_sock_graft(struct sock *sk, struct socket *parent)
4279 {
4280         struct inode_security_struct *isec = SOCK_INODE(parent)->i_security;
4281         struct sk_security_struct *sksec = sk->sk_security;
4282
4283         if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 ||
4284             sk->sk_family == PF_UNIX)
4285                 isec->sid = sksec->sid;
4286         sksec->sclass = isec->sclass;
4287 }
4288
4289 static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4290                                      struct request_sock *req)
4291 {
4292         struct sk_security_struct *sksec = sk->sk_security;
4293         int err;
4294         u16 family = sk->sk_family;
4295         u32 newsid;
4296         u32 peersid;
4297
4298         /* handle mapped IPv4 packets arriving via IPv6 sockets */
4299         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4300                 family = PF_INET;
4301
4302         err = selinux_skb_peerlbl_sid(skb, family, &peersid);
4303         if (err)
4304                 return err;
4305         if (peersid == SECSID_NULL) {
4306                 req->secid = sksec->sid;
4307                 req->peer_secid = SECSID_NULL;
4308         } else {
4309                 err = security_sid_mls_copy(sksec->sid, peersid, &newsid);
4310                 if (err)
4311                         return err;
4312                 req->secid = newsid;
4313                 req->peer_secid = peersid;
4314         }
4315
4316         return selinux_netlbl_inet_conn_request(req, family);
4317 }
4318
4319 static void selinux_inet_csk_clone(struct sock *newsk,
4320                                    const struct request_sock *req)
4321 {
4322         struct sk_security_struct *newsksec = newsk->sk_security;
4323
4324         newsksec->sid = req->secid;
4325         newsksec->peer_sid = req->peer_secid;
4326         /* NOTE: Ideally, we should also get the isec->sid for the
4327            new socket in sync, but we don't have the isec available yet.
4328            So we will wait until sock_graft to do it, by which
4329            time it will have been created and available. */
4330
4331         /* We don't need to take any sort of lock here as we are the only
4332          * thread with access to newsksec */
4333         selinux_netlbl_inet_csk_clone(newsk, req->rsk_ops->family);
4334 }
4335
4336 static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
4337 {
4338         u16 family = sk->sk_family;
4339         struct sk_security_struct *sksec = sk->sk_security;
4340
4341         /* handle mapped IPv4 packets arriving via IPv6 sockets */
4342         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4343                 family = PF_INET;
4344
4345         selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid);
4346 }
4347
4348 static int selinux_secmark_relabel_packet(u32 sid)
4349 {
4350         const struct task_security_struct *__tsec;
4351         u32 tsid;
4352
4353         __tsec = current_security();
4354         tsid = __tsec->sid;
4355
4356         return avc_has_perm(tsid, sid, SECCLASS_PACKET, PACKET__RELABELTO, NULL);
4357 }
4358
4359 static void selinux_secmark_refcount_inc(void)
4360 {
4361         atomic_inc(&selinux_secmark_refcount);
4362 }
4363
4364 static void selinux_secmark_refcount_dec(void)
4365 {
4366         atomic_dec(&selinux_secmark_refcount);
4367 }
4368
4369 static void selinux_req_classify_flow(const struct request_sock *req,
4370                                       struct flowi *fl)
4371 {
4372         fl->secid = req->secid;
4373 }
4374
4375 static int selinux_tun_dev_create(void)
4376 {
4377         u32 sid = current_sid();
4378
4379         /* we aren't taking into account the "sockcreate" SID since the socket
4380          * that is being created here is not a socket in the traditional sense,
4381          * instead it is a private sock, accessible only to the kernel, and
4382          * representing a wide range of network traffic spanning multiple
4383          * connections unlike traditional sockets - check the TUN driver to
4384          * get a better understanding of why this socket is special */
4385
4386         return avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__CREATE,
4387                             NULL);
4388 }
4389
4390 static void selinux_tun_dev_post_create(struct sock *sk)
4391 {
4392         struct sk_security_struct *sksec = sk->sk_security;
4393
4394         /* we don't currently perform any NetLabel based labeling here and it
4395          * isn't clear that we would want to do so anyway; while we could apply
4396          * labeling without the support of the TUN user the resulting labeled
4397          * traffic from the other end of the connection would almost certainly
4398          * cause confusion to the TUN user that had no idea network labeling
4399          * protocols were being used */
4400
4401         /* see the comments in selinux_tun_dev_create() about why we don't use
4402          * the sockcreate SID here */
4403
4404         sksec->sid = current_sid();
4405         sksec->sclass = SECCLASS_TUN_SOCKET;
4406 }
4407
4408 static int selinux_tun_dev_attach(struct sock *sk)
4409 {
4410         struct sk_security_struct *sksec = sk->sk_security;
4411         u32 sid = current_sid();
4412         int err;
4413
4414         err = avc_has_perm(sid, sksec->sid, SECCLASS_TUN_SOCKET,
4415                            TUN_SOCKET__RELABELFROM, NULL);
4416         if (err)
4417                 return err;
4418         err = avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET,
4419                            TUN_SOCKET__RELABELTO, NULL);
4420         if (err)
4421                 return err;
4422
4423         sksec->sid = sid;
4424
4425         return 0;
4426 }
4427
4428 static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb)
4429 {
4430         int err = 0;
4431         u32 perm;
4432         struct nlmsghdr *nlh;
4433         struct sk_security_struct *sksec = sk->sk_security;
4434
4435         if (skb->len < NLMSG_SPACE(0)) {
4436                 err = -EINVAL;
4437                 goto out;
4438         }
4439         nlh = nlmsg_hdr(skb);
4440
4441         err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm);
4442         if (err) {
4443                 if (err == -EINVAL) {
4444                         audit_log(current->audit_context, GFP_KERNEL, AUDIT_SELINUX_ERR,
4445                                   "SELinux:  unrecognized netlink message"
4446                                   " type=%hu for sclass=%hu\n",
4447                                   nlh->nlmsg_type, sksec->sclass);
4448                         if (!selinux_enforcing || security_get_allow_unknown())
4449                                 err = 0;
4450                 }
4451
4452                 /* Ignore */
4453                 if (err == -ENOENT)
4454                         err = 0;
4455                 goto out;
4456         }
4457
4458         err = sock_has_perm(current, sk, perm);
4459 out:
4460         return err;
4461 }
4462
4463 #ifdef CONFIG_NETFILTER
4464
4465 static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
4466                                        u16 family)
4467 {
4468         int err;
4469         char *addrp;
4470         u32 peer_sid;
4471         struct common_audit_data ad;
4472         u8 secmark_active;
4473         u8 netlbl_active;
4474         u8 peerlbl_active;
4475
4476         if (!selinux_policycap_netpeer)
4477                 return NF_ACCEPT;
4478
4479         secmark_active = selinux_secmark_enabled();
4480         netlbl_active = netlbl_enabled();
4481         peerlbl_active = netlbl_active || selinux_xfrm_enabled();
4482         if (!secmark_active && !peerlbl_active)
4483                 return NF_ACCEPT;
4484
4485         if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
4486                 return NF_DROP;
4487
4488         COMMON_AUDIT_DATA_INIT(&ad, NET);
4489         ad.u.net.netif = ifindex;
4490         ad.u.net.family = family;
4491         if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0)
4492                 return NF_DROP;
4493
4494         if (peerlbl_active) {
4495                 err = selinux_inet_sys_rcv_skb(ifindex, addrp, family,
4496                                                peer_sid, &ad);
4497                 if (err) {
4498                         selinux_netlbl_err(skb, err, 1);
4499                         return NF_DROP;
4500                 }
4501         }
4502
4503         if (secmark_active)
4504                 if (avc_has_perm(peer_sid, skb->secmark,
4505                                  SECCLASS_PACKET, PACKET__FORWARD_IN, &ad))
4506                         return NF_DROP;
4507
4508         if (netlbl_active)
4509                 /* we do this in the FORWARD path and not the POST_ROUTING
4510                  * path because we want to make sure we apply the necessary
4511                  * labeling before IPsec is applied so we can leverage AH
4512                  * protection */
4513                 if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0)
4514                         return NF_DROP;
4515
4516         return NF_ACCEPT;
4517 }
4518
4519 static unsigned int selinux_ipv4_forward(unsigned int hooknum,
4520                                          struct sk_buff *skb,
4521                                          const struct net_device *in,
4522                                          const struct net_device *out,
4523                                          int (*okfn)(struct sk_buff *))
4524 {
4525         return selinux_ip_forward(skb, in->ifindex, PF_INET);
4526 }
4527
4528 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4529 static unsigned int selinux_ipv6_forward(unsigned int hooknum,
4530                                          struct sk_buff *skb,
4531                                          const struct net_device *in,
4532                                          const struct net_device *out,
4533                                          int (*okfn)(struct sk_buff *))
4534 {
4535         return selinux_ip_forward(skb, in->ifindex, PF_INET6);
4536 }
4537 #endif  /* IPV6 */
4538
4539 static unsigned int selinux_ip_output(struct sk_buff *skb,
4540                                       u16 family)
4541 {
4542         u32 sid;
4543
4544         if (!netlbl_enabled())
4545                 return NF_ACCEPT;
4546
4547         /* we do this in the LOCAL_OUT path and not the POST_ROUTING path
4548          * because we want to make sure we apply the necessary labeling
4549          * before IPsec is applied so we can leverage AH protection */
4550         if (skb->sk) {
4551                 struct sk_security_struct *sksec = skb->sk->sk_security;
4552                 sid = sksec->sid;
4553         } else
4554                 sid = SECINITSID_KERNEL;
4555         if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0)
4556                 return NF_DROP;
4557
4558         return NF_ACCEPT;
4559 }
4560
4561 static unsigned int selinux_ipv4_output(unsigned int hooknum,
4562                                         struct sk_buff *skb,
4563                                         const struct net_device *in,
4564                                         const struct net_device *out,
4565                                         int (*okfn)(struct sk_buff *))
4566 {
4567         return selinux_ip_output(skb, PF_INET);
4568 }
4569
4570 static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb,
4571                                                 int ifindex,
4572                                                 u16 family)
4573 {
4574         struct sock *sk = skb->sk;
4575         struct sk_security_struct *sksec;
4576         struct common_audit_data ad;
4577         char *addrp;
4578         u8 proto;
4579
4580         if (sk == NULL)
4581                 return NF_ACCEPT;
4582         sksec = sk->sk_security;
4583
4584         COMMON_AUDIT_DATA_INIT(&ad, NET);
4585         ad.u.net.netif = ifindex;
4586         ad.u.net.family = family;
4587         if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
4588                 return NF_DROP;
4589
4590         if (selinux_secmark_enabled())
4591                 if (avc_has_perm(sksec->sid, skb->secmark,
4592                                  SECCLASS_PACKET, PACKET__SEND, &ad))
4593                         return NF_DROP_ERR(-ECONNREFUSED);
4594
4595         if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto))
4596                 return NF_DROP_ERR(-ECONNREFUSED);
4597
4598         return NF_ACCEPT;
4599 }
4600
4601 static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
4602                                          u16 family)
4603 {
4604         u32 secmark_perm;
4605         u32 peer_sid;
4606         struct sock *sk;
4607         struct common_audit_data ad;
4608         char *addrp;
4609         u8 secmark_active;
4610         u8 peerlbl_active;
4611
4612         /* If any sort of compatibility mode is enabled then handoff processing
4613          * to the selinux_ip_postroute_compat() function to deal with the
4614          * special handling.  We do this in an attempt to keep this function
4615          * as fast and as clean as possible. */
4616         if (!selinux_policycap_netpeer)
4617                 return selinux_ip_postroute_compat(skb, ifindex, family);
4618 #ifdef CONFIG_XFRM
4619         /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec
4620          * packet transformation so allow the packet to pass without any checks
4621          * since we'll have another chance to perform access control checks
4622          * when the packet is on it's final way out.
4623          * NOTE: there appear to be some IPv6 multicast cases where skb->dst
4624          *       is NULL, in this case go ahead and apply access control. */
4625         if (skb_dst(skb) != NULL && skb_dst(skb)->xfrm != NULL)
4626                 return NF_ACCEPT;
4627 #endif
4628         secmark_active = selinux_secmark_enabled();
4629         peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4630         if (!secmark_active && !peerlbl_active)
4631                 return NF_ACCEPT;
4632
4633         /* if the packet is being forwarded then get the peer label from the
4634          * packet itself; otherwise check to see if it is from a local
4635          * application or the kernel, if from an application get the peer label
4636          * from the sending socket, otherwise use the kernel's sid */
4637         sk = skb->sk;
4638         if (sk == NULL) {
4639                 if (skb->skb_iif) {
4640                         secmark_perm = PACKET__FORWARD_OUT;
4641                         if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
4642                                 return NF_DROP;
4643                 } else {
4644                         secmark_perm = PACKET__SEND;
4645                         peer_sid = SECINITSID_KERNEL;
4646                 }
4647         } else {
4648                 struct sk_security_struct *sksec = sk->sk_security;
4649                 peer_sid = sksec->sid;
4650                 secmark_perm = PACKET__SEND;
4651         }
4652
4653         COMMON_AUDIT_DATA_INIT(&ad, NET);
4654         ad.u.net.netif = ifindex;
4655         ad.u.net.family = family;
4656         if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL))
4657                 return NF_DROP;
4658
4659         if (secmark_active)
4660                 if (avc_has_perm(peer_sid, skb->secmark,
4661                                  SECCLASS_PACKET, secmark_perm, &ad))
4662                         return NF_DROP_ERR(-ECONNREFUSED);
4663
4664         if (peerlbl_active) {
4665                 u32 if_sid;
4666                 u32 node_sid;
4667
4668                 if (sel_netif_sid(ifindex, &if_sid))
4669                         return NF_DROP;
4670                 if (avc_has_perm(peer_sid, if_sid,
4671                                  SECCLASS_NETIF, NETIF__EGRESS, &ad))
4672                         return NF_DROP_ERR(-ECONNREFUSED);
4673
4674                 if (sel_netnode_sid(addrp, family, &node_sid))
4675                         return NF_DROP;
4676                 if (avc_has_perm(peer_sid, node_sid,
4677                                  SECCLASS_NODE, NODE__SENDTO, &ad))
4678                         return NF_DROP_ERR(-ECONNREFUSED);
4679         }
4680
4681         return NF_ACCEPT;
4682 }
4683
4684 static unsigned int selinux_ipv4_postroute(unsigned int hooknum,
4685                                            struct sk_buff *skb,
4686                                            const struct net_device *in,
4687                                            const struct net_device *out,
4688                                            int (*okfn)(struct sk_buff *))
4689 {
4690         return selinux_ip_postroute(skb, out->ifindex, PF_INET);
4691 }
4692
4693 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4694 static unsigned int selinux_ipv6_postroute(unsigned int hooknum,
4695                                            struct sk_buff *skb,
4696                                            const struct net_device *in,
4697                                            const struct net_device *out,
4698                                            int (*okfn)(struct sk_buff *))
4699 {
4700         return selinux_ip_postroute(skb, out->ifindex, PF_INET6);
4701 }
4702 #endif  /* IPV6 */
4703
4704 #endif  /* CONFIG_NETFILTER */
4705
4706 static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb)
4707 {
4708         int err;
4709
4710         err = cap_netlink_send(sk, skb);
4711         if (err)
4712                 return err;
4713
4714         return selinux_nlmsg_perm(sk, skb);
4715 }
4716
4717 static int selinux_netlink_recv(struct sk_buff *skb, int capability)
4718 {
4719         int err;
4720         struct common_audit_data ad;
4721
4722         err = cap_netlink_recv(skb, capability);
4723         if (err)
4724                 return err;
4725
4726         COMMON_AUDIT_DATA_INIT(&ad, CAP);
4727         ad.u.cap = capability;
4728
4729         return avc_has_perm(NETLINK_CB(skb).sid, NETLINK_CB(skb).sid,
4730                             SECCLASS_CAPABILITY, CAP_TO_MASK(capability), &ad);
4731 }
4732
4733 static int ipc_alloc_security(struct task_struct *task,
4734                               struct kern_ipc_perm *perm,
4735                               u16 sclass)
4736 {
4737         struct ipc_security_struct *isec;
4738         u32 sid;
4739
4740         isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
4741         if (!isec)
4742                 return -ENOMEM;
4743
4744         sid = task_sid(task);
4745         isec->sclass = sclass;
4746         isec->sid = sid;
4747         perm->security = isec;
4748
4749         return 0;
4750 }
4751
4752 static void ipc_free_security(struct kern_ipc_perm *perm)
4753 {
4754         struct ipc_security_struct *isec = perm->security;
4755         perm->security = NULL;
4756         kfree(isec);
4757 }
4758
4759 static int msg_msg_alloc_security(struct msg_msg *msg)
4760 {
4761         struct msg_security_struct *msec;
4762
4763         msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
4764         if (!msec)
4765                 return -ENOMEM;
4766
4767         msec->sid = SECINITSID_UNLABELED;
4768         msg->security = msec;
4769
4770         return 0;
4771 }
4772
4773 static void msg_msg_free_security(struct msg_msg *msg)
4774 {
4775         struct msg_security_struct *msec = msg->security;
4776
4777         msg->security = NULL;
4778         kfree(msec);
4779 }
4780
4781 static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
4782                         u32 perms)
4783 {
4784         struct ipc_security_struct *isec;
4785         struct common_audit_data ad;
4786         u32 sid = current_sid();
4787
4788         isec = ipc_perms->security;
4789
4790         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4791         ad.u.ipc_id = ipc_perms->key;
4792
4793         return avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
4794 }
4795
4796 static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
4797 {
4798         return msg_msg_alloc_security(msg);
4799 }
4800
4801 static void selinux_msg_msg_free_security(struct msg_msg *msg)
4802 {
4803         msg_msg_free_security(msg);
4804 }
4805
4806 /* message queue security operations */
4807 static int selinux_msg_queue_alloc_security(struct msg_queue *msq)
4808 {
4809         struct ipc_security_struct *isec;
4810         struct common_audit_data ad;
4811         u32 sid = current_sid();
4812         int rc;
4813
4814         rc = ipc_alloc_security(current, &msq->q_perm, SECCLASS_MSGQ);
4815         if (rc)
4816                 return rc;
4817
4818         isec = msq->q_perm.security;
4819
4820         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4821         ad.u.ipc_id = msq->q_perm.key;
4822
4823         rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
4824                           MSGQ__CREATE, &ad);
4825         if (rc) {
4826                 ipc_free_security(&msq->q_perm);
4827                 return rc;
4828         }
4829         return 0;
4830 }
4831
4832 static void selinux_msg_queue_free_security(struct msg_queue *msq)
4833 {
4834         ipc_free_security(&msq->q_perm);
4835 }
4836
4837 static int selinux_msg_queue_associate(struct msg_queue *msq, int msqflg)
4838 {
4839         struct ipc_security_struct *isec;
4840         struct common_audit_data ad;
4841         u32 sid = current_sid();
4842
4843         isec = msq->q_perm.security;
4844
4845         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4846         ad.u.ipc_id = msq->q_perm.key;
4847
4848         return avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
4849                             MSGQ__ASSOCIATE, &ad);
4850 }
4851
4852 static int selinux_msg_queue_msgctl(struct msg_queue *msq, int cmd)
4853 {
4854         int err;
4855         int perms;
4856
4857         switch (cmd) {
4858         case IPC_INFO:
4859         case MSG_INFO:
4860                 /* No specific object, just general system-wide information. */
4861                 return task_has_system(current, SYSTEM__IPC_INFO);
4862         case IPC_STAT:
4863         case MSG_STAT:
4864                 perms = MSGQ__GETATTR | MSGQ__ASSOCIATE;
4865                 break;
4866         case IPC_SET:
4867                 perms = MSGQ__SETATTR;
4868                 break;
4869         case IPC_RMID:
4870                 perms = MSGQ__DESTROY;
4871                 break;
4872         default:
4873                 return 0;
4874         }
4875
4876         err = ipc_has_perm(&msq->q_perm, perms);
4877         return err;
4878 }
4879
4880 static int selinux_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, int msqflg)
4881 {
4882         struct ipc_security_struct *isec;
4883         struct msg_security_struct *msec;
4884         struct common_audit_data ad;
4885         u32 sid = current_sid();
4886         int rc;
4887
4888         isec = msq->q_perm.security;
4889         msec = msg->security;
4890
4891         /*
4892          * First time through, need to assign label to the message
4893          */
4894         if (msec->sid == SECINITSID_UNLABELED) {
4895                 /*
4896                  * Compute new sid based on current process and
4897                  * message queue this message will be stored in
4898                  */
4899                 rc = security_transition_sid(sid, isec->sid, SECCLASS_MSG,
4900                                              NULL, &msec->sid);
4901                 if (rc)
4902                         return rc;
4903         }
4904
4905         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4906         ad.u.ipc_id = msq->q_perm.key;
4907
4908         /* Can this process write to the queue? */
4909         rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
4910                           MSGQ__WRITE, &ad);
4911         if (!rc)
4912                 /* Can this process send the message */
4913                 rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG,
4914                                   MSG__SEND, &ad);
4915         if (!rc)
4916                 /* Can the message be put in the queue? */
4917                 rc = avc_has_perm(msec->sid, isec->sid, SECCLASS_MSGQ,
4918                                   MSGQ__ENQUEUE, &ad);
4919
4920         return rc;
4921 }
4922
4923 static int selinux_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
4924                                     struct task_struct *target,
4925                                     long type, int mode)
4926 {
4927         struct ipc_security_struct *isec;
4928         struct msg_security_struct *msec;
4929         struct common_audit_data ad;
4930         u32 sid = task_sid(target);
4931         int rc;
4932
4933         isec = msq->q_perm.security;
4934         msec = msg->security;
4935
4936         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4937         ad.u.ipc_id = msq->q_perm.key;
4938
4939         rc = avc_has_perm(sid, isec->sid,
4940                           SECCLASS_MSGQ, MSGQ__READ, &ad);
4941         if (!rc)
4942                 rc = avc_has_perm(sid, msec->sid,
4943                                   SECCLASS_MSG, MSG__RECEIVE, &ad);
4944         return rc;
4945 }
4946
4947 /* Shared Memory security operations */
4948 static int selinux_shm_alloc_security(struct shmid_kernel *shp)
4949 {
4950         struct ipc_security_struct *isec;
4951         struct common_audit_data ad;
4952         u32 sid = current_sid();
4953         int rc;
4954
4955         rc = ipc_alloc_security(current, &shp->shm_perm, SECCLASS_SHM);
4956         if (rc)
4957                 return rc;
4958
4959         isec = shp->shm_perm.security;
4960
4961         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4962         ad.u.ipc_id = shp->shm_perm.key;
4963
4964         rc = avc_has_perm(sid, isec->sid, SECCLASS_SHM,
4965                           SHM__CREATE, &ad);
4966         if (rc) {
4967                 ipc_free_security(&shp->shm_perm);
4968                 return rc;
4969         }
4970         return 0;
4971 }
4972
4973 static void selinux_shm_free_security(struct shmid_kernel *shp)
4974 {
4975         ipc_free_security(&shp->shm_perm);
4976 }
4977
4978 static int selinux_shm_associate(struct shmid_kernel *shp, int shmflg)
4979 {
4980         struct ipc_security_struct *isec;
4981         struct common_audit_data ad;
4982         u32 sid = current_sid();
4983
4984         isec = shp->shm_perm.security;
4985
4986         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4987         ad.u.ipc_id = shp->shm_perm.key;
4988
4989         return avc_has_perm(sid, isec->sid, SECCLASS_SHM,
4990                             SHM__ASSOCIATE, &ad);
4991 }
4992
4993 /* Note, at this point, shp is locked down */
4994 static int selinux_shm_shmctl(struct shmid_kernel *shp, int cmd)
4995 {
4996         int perms;
4997         int err;
4998
4999         switch (cmd) {
5000         case IPC_INFO:
5001         case SHM_INFO:
5002                 /* No specific object, just general system-wide information. */
5003                 return task_has_system(current, SYSTEM__IPC_INFO);
5004         case IPC_STAT:
5005         case SHM_STAT:
5006                 perms = SHM__GETATTR | SHM__ASSOCIATE;
5007                 break;
5008         case IPC_SET:
5009                 perms = SHM__SETATTR;
5010                 break;
5011         case SHM_LOCK:
5012         case SHM_UNLOCK:
5013                 perms = SHM__LOCK;
5014                 break;
5015         case IPC_RMID:
5016                 perms = SHM__DESTROY;
5017                 break;
5018         default:
5019                 return 0;
5020         }
5021
5022         err = ipc_has_perm(&shp->shm_perm, perms);
5023         return err;
5024 }
5025
5026 static int selinux_shm_shmat(struct shmid_kernel *shp,
5027                              char __user *shmaddr, int shmflg)
5028 {
5029         u32 perms;
5030
5031         if (shmflg & SHM_RDONLY)
5032                 perms = SHM__READ;
5033         else
5034                 perms = SHM__READ | SHM__WRITE;
5035
5036         return ipc_has_perm(&shp->shm_perm, perms);
5037 }
5038
5039 /* Semaphore security operations */
5040 static int selinux_sem_alloc_security(struct sem_array *sma)
5041 {
5042         struct ipc_security_struct *isec;
5043         struct common_audit_data ad;
5044         u32 sid = current_sid();
5045         int rc;
5046
5047         rc = ipc_alloc_security(current, &sma->sem_perm, SECCLASS_SEM);
5048         if (rc)
5049                 return rc;
5050
5051         isec = sma->sem_perm.security;
5052
5053         COMMON_AUDIT_DATA_INIT(&ad, IPC);
5054         ad.u.ipc_id = sma->sem_perm.key;
5055
5056         rc = avc_has_perm(sid, isec->sid, SECCLASS_SEM,
5057                           SEM__CREATE, &ad);
5058         if (rc) {
5059                 ipc_free_security(&sma->sem_perm);
5060                 return rc;
5061         }
5062         return 0;
5063 }
5064
5065 static void selinux_sem_free_security(struct sem_array *sma)
5066 {
5067         ipc_free_security(&sma->sem_perm);
5068 }
5069
5070 static int selinux_sem_associate(struct sem_array *sma, int semflg)
5071 {
5072         struct ipc_security_struct *isec;
5073         struct common_audit_data ad;
5074         u32 sid = current_sid();
5075
5076         isec = sma->sem_perm.security;
5077
5078         COMMON_AUDIT_DATA_INIT(&ad, IPC);
5079         ad.u.ipc_id = sma->sem_perm.key;
5080
5081         return avc_has_perm(sid, isec->sid, SECCLASS_SEM,
5082                             SEM__ASSOCIATE, &ad);
5083 }
5084
5085 /* Note, at this point, sma is locked down */
5086 static int selinux_sem_semctl(struct sem_array *sma, int cmd)
5087 {
5088         int err;
5089         u32 perms;
5090
5091         switch (cmd) {
5092         case IPC_INFO:
5093         case SEM_INFO:
5094                 /* No specific object, just general system-wide information. */
5095                 return task_has_system(current, SYSTEM__IPC_INFO);
5096         case GETPID:
5097         case GETNCNT:
5098         case GETZCNT:
5099                 perms = SEM__GETATTR;
5100                 break;
5101         case GETVAL:
5102         case GETALL:
5103                 perms = SEM__READ;
5104                 break;
5105         case SETVAL:
5106         case SETALL:
5107                 perms = SEM__WRITE;
5108                 break;
5109         case IPC_RMID:
5110                 perms = SEM__DESTROY;
5111                 break;
5112         case IPC_SET:
5113                 perms = SEM__SETATTR;
5114                 break;
5115         case IPC_STAT:
5116         case SEM_STAT:
5117                 perms = SEM__GETATTR | SEM__ASSOCIATE;
5118                 break;
5119         default:
5120                 return 0;
5121         }
5122
5123         err = ipc_has_perm(&sma->sem_perm, perms);
5124         return err;
5125 }
5126
5127 static int selinux_sem_semop(struct sem_array *sma,
5128                              struct sembuf *sops, unsigned nsops, int alter)
5129 {
5130         u32 perms;
5131
5132         if (alter)
5133                 perms = SEM__READ | SEM__WRITE;
5134         else
5135                 perms = SEM__READ;
5136
5137         return ipc_has_perm(&sma->sem_perm, perms);
5138 }
5139
5140 static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
5141 {
5142         u32 av = 0;
5143
5144         av = 0;
5145         if (flag & S_IRUGO)
5146                 av |= IPC__UNIX_READ;
5147         if (flag & S_IWUGO)
5148                 av |= IPC__UNIX_WRITE;
5149
5150         if (av == 0)
5151                 return 0;
5152
5153         return ipc_has_perm(ipcp, av);
5154 }
5155
5156 static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
5157 {
5158         struct ipc_security_struct *isec = ipcp->security;
5159         *secid = isec->sid;
5160 }
5161
5162 static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode)
5163 {
5164         if (inode)
5165                 inode_doinit_with_dentry(inode, dentry);
5166 }
5167
5168 static int selinux_getprocattr(struct task_struct *p,
5169                                char *name, char **value)
5170 {
5171         const struct task_security_struct *__tsec;
5172         u32 sid;
5173         int error;
5174         unsigned len;
5175
5176         if (current != p) {
5177                 error = current_has_perm(p, PROCESS__GETATTR);
5178                 if (error)
5179                         return error;
5180         }
5181
5182         rcu_read_lock();
5183         __tsec = __task_cred(p)->security;
5184
5185         if (!strcmp(name, "current"))
5186                 sid = __tsec->sid;
5187         else if (!strcmp(name, "prev"))
5188                 sid = __tsec->osid;
5189         else if (!strcmp(name, "exec"))
5190                 sid = __tsec->exec_sid;
5191         else if (!strcmp(name, "fscreate"))
5192                 sid = __tsec->create_sid;
5193         else if (!strcmp(name, "keycreate"))
5194                 sid = __tsec->keycreate_sid;
5195         else if (!strcmp(name, "sockcreate"))
5196                 sid = __tsec->sockcreate_sid;
5197         else
5198                 goto invalid;
5199         rcu_read_unlock();
5200
5201         if (!sid)
5202                 return 0;
5203
5204         error = security_sid_to_context(sid, value, &len);
5205         if (error)
5206                 return error;
5207         return len;
5208
5209 invalid:
5210         rcu_read_unlock();
5211         return -EINVAL;
5212 }
5213
5214 static int selinux_setprocattr(struct task_struct *p,
5215                                char *name, void *value, size_t size)
5216 {
5217         struct task_security_struct *tsec;
5218         struct task_struct *tracer;
5219         struct cred *new;
5220         u32 sid = 0, ptsid;
5221         int error;
5222         char *str = value;
5223
5224         if (current != p) {
5225                 /* SELinux only allows a process to change its own
5226                    security attributes. */
5227                 return -EACCES;
5228         }
5229
5230         /*
5231          * Basic control over ability to set these attributes at all.
5232          * current == p, but we'll pass them separately in case the
5233          * above restriction is ever removed.
5234          */
5235         if (!strcmp(name, "exec"))
5236                 error = current_has_perm(p, PROCESS__SETEXEC);
5237         else if (!strcmp(name, "fscreate"))
5238                 error = current_has_perm(p, PROCESS__SETFSCREATE);
5239         else if (!strcmp(name, "keycreate"))
5240                 error = current_has_perm(p, PROCESS__SETKEYCREATE);
5241         else if (!strcmp(name, "sockcreate"))
5242                 error = current_has_perm(p, PROCESS__SETSOCKCREATE);
5243         else if (!strcmp(name, "current"))
5244                 error = current_has_perm(p, PROCESS__SETCURRENT);
5245         else
5246                 error = -EINVAL;
5247         if (error)
5248                 return error;
5249
5250         /* Obtain a SID for the context, if one was specified. */
5251         if (size && str[1] && str[1] != '\n') {
5252                 if (str[size-1] == '\n') {
5253                         str[size-1] = 0;
5254                         size--;
5255                 }
5256                 error = security_context_to_sid(value, size, &sid);
5257                 if (error == -EINVAL && !strcmp(name, "fscreate")) {
5258                         if (!capable(CAP_MAC_ADMIN))
5259                                 return error;
5260                         error = security_context_to_sid_force(value, size,
5261                                                               &sid);
5262                 }
5263                 if (error)
5264                         return error;
5265         }
5266
5267         new = prepare_creds();
5268         if (!new)
5269                 return -ENOMEM;
5270
5271         /* Permission checking based on the specified context is
5272            performed during the actual operation (execve,
5273            open/mkdir/...), when we know the full context of the
5274            operation.  See selinux_bprm_set_creds for the execve
5275            checks and may_create for the file creation checks. The
5276            operation will then fail if the context is not permitted. */
5277         tsec = new->security;
5278         if (!strcmp(name, "exec")) {
5279                 tsec->exec_sid = sid;
5280         } else if (!strcmp(name, "fscreate")) {
5281                 tsec->create_sid = sid;
5282         } else if (!strcmp(name, "keycreate")) {
5283                 error = may_create_key(sid, p);
5284                 if (error)
5285                         goto abort_change;
5286                 tsec->keycreate_sid = sid;
5287         } else if (!strcmp(name, "sockcreate")) {
5288                 tsec->sockcreate_sid = sid;
5289         } else if (!strcmp(name, "current")) {
5290                 error = -EINVAL;
5291                 if (sid == 0)
5292                         goto abort_change;
5293
5294                 /* Only allow single threaded processes to change context */
5295                 error = -EPERM;
5296                 if (!current_is_single_threaded()) {
5297                         error = security_bounded_transition(tsec->sid, sid);
5298                         if (error)
5299                                 goto abort_change;
5300                 }
5301
5302                 /* Check permissions for the transition. */
5303                 error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
5304                                      PROCESS__DYNTRANSITION, NULL);
5305                 if (error)
5306                         goto abort_change;
5307
5308                 /* Check for ptracing, and update the task SID if ok.
5309                    Otherwise, leave SID unchanged and fail. */
5310                 ptsid = 0;
5311                 task_lock(p);
5312                 tracer = tracehook_tracer_task(p);
5313                 if (tracer)
5314                         ptsid = task_sid(tracer);
5315                 task_unlock(p);
5316
5317                 if (tracer) {
5318                         error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS,
5319                                              PROCESS__PTRACE, NULL);
5320                         if (error)
5321                                 goto abort_change;
5322                 }
5323
5324                 tsec->sid = sid;
5325         } else {
5326                 error = -EINVAL;
5327                 goto abort_change;
5328         }
5329
5330         commit_creds(new);
5331         return size;
5332
5333 abort_change:
5334         abort_creds(new);
5335         return error;
5336 }
5337
5338 static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
5339 {
5340         return security_sid_to_context(secid, secdata, seclen);
5341 }
5342
5343 static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
5344 {
5345         return security_context_to_sid(secdata, seclen, secid);
5346 }
5347
5348 static void selinux_release_secctx(char *secdata, u32 seclen)
5349 {
5350         kfree(secdata);
5351 }
5352
5353 /*
5354  *      called with inode->i_mutex locked
5355  */
5356 static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
5357 {
5358         return selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, ctxlen, 0);
5359 }
5360
5361 /*
5362  *      called with inode->i_mutex locked
5363  */
5364 static int selinux_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
5365 {
5366         return __vfs_setxattr_noperm(dentry, XATTR_NAME_SELINUX, ctx, ctxlen, 0);
5367 }
5368
5369 static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
5370 {
5371         int len = 0;
5372         len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX,
5373                                                 ctx, true);
5374         if (len < 0)
5375                 return len;
5376         *ctxlen = len;
5377         return 0;
5378 }
5379 #ifdef CONFIG_KEYS
5380
5381 static int selinux_key_alloc(struct key *k, const struct cred *cred,
5382                              unsigned long flags)
5383 {
5384         const struct task_security_struct *tsec;
5385         struct key_security_struct *ksec;
5386
5387         ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
5388         if (!ksec)
5389                 return -ENOMEM;
5390
5391         tsec = cred->security;
5392         if (tsec->keycreate_sid)
5393                 ksec->sid = tsec->keycreate_sid;
5394         else
5395                 ksec->sid = tsec->sid;
5396
5397         k->security = ksec;
5398         return 0;
5399 }
5400
5401 static void selinux_key_free(struct key *k)
5402 {
5403         struct key_security_struct *ksec = k->security;
5404
5405         k->security = NULL;
5406         kfree(ksec);
5407 }
5408
5409 static int selinux_key_permission(key_ref_t key_ref,
5410                                   const struct cred *cred,
5411                                   key_perm_t perm)
5412 {
5413         struct key *key;
5414         struct key_security_struct *ksec;
5415         u32 sid;
5416
5417         /* if no specific permissions are requested, we skip the
5418            permission check. No serious, additional covert channels
5419            appear to be created. */
5420         if (perm == 0)
5421                 return 0;
5422
5423         sid = cred_sid(cred);
5424
5425         key = key_ref_to_ptr(key_ref);
5426         ksec = key->security;
5427
5428         return avc_has_perm(sid, ksec->sid, SECCLASS_KEY, perm, NULL);
5429 }
5430
5431 static int selinux_key_getsecurity(struct key *key, char **_buffer)
5432 {
5433         struct key_security_struct *ksec = key->security;
5434         char *context = NULL;
5435         unsigned len;
5436         int rc;
5437
5438         rc = security_sid_to_context(ksec->sid, &context, &len);
5439         if (!rc)
5440                 rc = len;
5441         *_buffer = context;
5442         return rc;
5443 }
5444
5445 #endif
5446
5447 static struct security_operations selinux_ops = {
5448         .name =                         "selinux",
5449
5450         .ptrace_access_check =          selinux_ptrace_access_check,
5451         .ptrace_traceme =               selinux_ptrace_traceme,
5452         .capget =                       selinux_capget,
5453         .capset =                       selinux_capset,
5454         .capable =                      selinux_capable,
5455         .quotactl =                     selinux_quotactl,
5456         .quota_on =                     selinux_quota_on,
5457         .syslog =                       selinux_syslog,
5458         .vm_enough_memory =             selinux_vm_enough_memory,
5459
5460         .netlink_send =                 selinux_netlink_send,
5461         .netlink_recv =                 selinux_netlink_recv,
5462
5463         .bprm_set_creds =               selinux_bprm_set_creds,
5464         .bprm_committing_creds =        selinux_bprm_committing_creds,
5465         .bprm_committed_creds =         selinux_bprm_committed_creds,
5466         .bprm_secureexec =              selinux_bprm_secureexec,
5467
5468         .sb_alloc_security =            selinux_sb_alloc_security,
5469         .sb_free_security =             selinux_sb_free_security,
5470         .sb_copy_data =                 selinux_sb_copy_data,
5471         .sb_remount =                   selinux_sb_remount,
5472         .sb_kern_mount =                selinux_sb_kern_mount,
5473         .sb_show_options =              selinux_sb_show_options,
5474         .sb_statfs =                    selinux_sb_statfs,
5475         .sb_mount =                     selinux_mount,
5476         .sb_umount =                    selinux_umount,
5477         .sb_set_mnt_opts =              selinux_set_mnt_opts,
5478         .sb_clone_mnt_opts =            selinux_sb_clone_mnt_opts,
5479         .sb_parse_opts_str =            selinux_parse_opts_str,
5480
5481
5482         .inode_alloc_security =         selinux_inode_alloc_security,
5483         .inode_free_security =          selinux_inode_free_security,
5484         .inode_init_security =          selinux_inode_init_security,
5485         .inode_create =                 selinux_inode_create,
5486         .inode_link =                   selinux_inode_link,
5487         .inode_unlink =                 selinux_inode_unlink,
5488         .inode_symlink =                selinux_inode_symlink,
5489         .inode_mkdir =                  selinux_inode_mkdir,
5490         .inode_rmdir =                  selinux_inode_rmdir,
5491         .inode_mknod =                  selinux_inode_mknod,
5492         .inode_rename =                 selinux_inode_rename,
5493         .inode_readlink =               selinux_inode_readlink,
5494         .inode_follow_link =            selinux_inode_follow_link,
5495         .inode_permission =             selinux_inode_permission,
5496         .inode_setattr =                selinux_inode_setattr,
5497         .inode_getattr =                selinux_inode_getattr,
5498         .inode_setxattr =               selinux_inode_setxattr,
5499         .inode_post_setxattr =          selinux_inode_post_setxattr,
5500         .inode_getxattr =               selinux_inode_getxattr,
5501         .inode_listxattr =              selinux_inode_listxattr,
5502         .inode_removexattr =            selinux_inode_removexattr,
5503         .inode_getsecurity =            selinux_inode_getsecurity,
5504         .inode_setsecurity =            selinux_inode_setsecurity,
5505         .inode_listsecurity =           selinux_inode_listsecurity,
5506         .inode_getsecid =               selinux_inode_getsecid,
5507
5508         .file_permission =              selinux_file_permission,
5509         .file_alloc_security =          selinux_file_alloc_security,
5510         .file_free_security =           selinux_file_free_security,
5511         .file_ioctl =                   selinux_file_ioctl,
5512         .file_mmap =                    selinux_file_mmap,
5513         .file_mprotect =                selinux_file_mprotect,
5514         .file_lock =                    selinux_file_lock,
5515         .file_fcntl =                   selinux_file_fcntl,
5516         .file_set_fowner =              selinux_file_set_fowner,
5517         .file_send_sigiotask =          selinux_file_send_sigiotask,
5518         .file_receive =                 selinux_file_receive,
5519
5520         .dentry_open =                  selinux_dentry_open,
5521
5522         .task_create =                  selinux_task_create,
5523         .cred_alloc_blank =             selinux_cred_alloc_blank,
5524         .cred_free =                    selinux_cred_free,
5525         .cred_prepare =                 selinux_cred_prepare,
5526         .cred_transfer =                selinux_cred_transfer,
5527         .kernel_act_as =                selinux_kernel_act_as,
5528         .kernel_create_files_as =       selinux_kernel_create_files_as,
5529         .kernel_module_request =        selinux_kernel_module_request,
5530         .task_setpgid =                 selinux_task_setpgid,
5531         .task_getpgid =                 selinux_task_getpgid,
5532         .task_getsid =                  selinux_task_getsid,
5533         .task_getsecid =                selinux_task_getsecid,
5534         .task_setnice =                 selinux_task_setnice,
5535         .task_setioprio =               selinux_task_setioprio,
5536         .task_getioprio =               selinux_task_getioprio,
5537         .task_setrlimit =               selinux_task_setrlimit,
5538         .task_setscheduler =            selinux_task_setscheduler,
5539         .task_getscheduler =            selinux_task_getscheduler,
5540         .task_movememory =              selinux_task_movememory,
5541         .task_kill =                    selinux_task_kill,
5542         .task_wait =                    selinux_task_wait,
5543         .task_to_inode =                selinux_task_to_inode,
5544
5545         .ipc_permission =               selinux_ipc_permission,
5546         .ipc_getsecid =                 selinux_ipc_getsecid,
5547
5548         .msg_msg_alloc_security =       selinux_msg_msg_alloc_security,
5549         .msg_msg_free_security =        selinux_msg_msg_free_security,
5550
5551         .msg_queue_alloc_security =     selinux_msg_queue_alloc_security,
5552         .msg_queue_free_security =      selinux_msg_queue_free_security,
5553         .msg_queue_associate =          selinux_msg_queue_associate,
5554         .msg_queue_msgctl =             selinux_msg_queue_msgctl,
5555         .msg_queue_msgsnd =             selinux_msg_queue_msgsnd,
5556         .msg_queue_msgrcv =             selinux_msg_queue_msgrcv,
5557
5558         .shm_alloc_security =           selinux_shm_alloc_security,
5559         .shm_free_security =            selinux_shm_free_security,
5560         .shm_associate =                selinux_shm_associate,
5561         .shm_shmctl =                   selinux_shm_shmctl,
5562         .shm_shmat =                    selinux_shm_shmat,
5563
5564         .sem_alloc_security =           selinux_sem_alloc_security,
5565         .sem_free_security =            selinux_sem_free_security,
5566         .sem_associate =                selinux_sem_associate,
5567         .sem_semctl =                   selinux_sem_semctl,
5568         .sem_semop =                    selinux_sem_semop,
5569
5570         .d_instantiate =                selinux_d_instantiate,
5571
5572         .getprocattr =                  selinux_getprocattr,
5573         .setprocattr =                  selinux_setprocattr,
5574
5575         .secid_to_secctx =              selinux_secid_to_secctx,
5576         .secctx_to_secid =              selinux_secctx_to_secid,
5577         .release_secctx =               selinux_release_secctx,
5578         .inode_notifysecctx =           selinux_inode_notifysecctx,
5579         .inode_setsecctx =              selinux_inode_setsecctx,
5580         .inode_getsecctx =              selinux_inode_getsecctx,
5581
5582         .unix_stream_connect =          selinux_socket_unix_stream_connect,
5583         .unix_may_send =                selinux_socket_unix_may_send,
5584
5585         .socket_create =                selinux_socket_create,
5586         .socket_post_create =           selinux_socket_post_create,
5587         .socket_bind =                  selinux_socket_bind,
5588         .socket_connect =               selinux_socket_connect,
5589         .socket_listen =                selinux_socket_listen,
5590         .socket_accept =                selinux_socket_accept,
5591         .socket_sendmsg =               selinux_socket_sendmsg,
5592         .socket_recvmsg =               selinux_socket_recvmsg,
5593         .socket_getsockname =           selinux_socket_getsockname,
5594         .socket_getpeername =           selinux_socket_getpeername,
5595         .socket_getsockopt =            selinux_socket_getsockopt,
5596         .socket_setsockopt =            selinux_socket_setsockopt,
5597         .socket_shutdown =              selinux_socket_shutdown,
5598         .socket_sock_rcv_skb =          selinux_socket_sock_rcv_skb,
5599         .socket_getpeersec_stream =     selinux_socket_getpeersec_stream,
5600         .socket_getpeersec_dgram =      selinux_socket_getpeersec_dgram,
5601         .sk_alloc_security =            selinux_sk_alloc_security,
5602         .sk_free_security =             selinux_sk_free_security,
5603         .sk_clone_security =            selinux_sk_clone_security,
5604         .sk_getsecid =                  selinux_sk_getsecid,
5605         .sock_graft =                   selinux_sock_graft,
5606         .inet_conn_request =            selinux_inet_conn_request,
5607         .inet_csk_clone =               selinux_inet_csk_clone,
5608         .inet_conn_established =        selinux_inet_conn_established,
5609         .secmark_relabel_packet =       selinux_secmark_relabel_packet,
5610         .secmark_refcount_inc =         selinux_secmark_refcount_inc,
5611         .secmark_refcount_dec =         selinux_secmark_refcount_dec,
5612         .req_classify_flow =            selinux_req_classify_flow,
5613         .tun_dev_create =               selinux_tun_dev_create,
5614         .tun_dev_post_create =          selinux_tun_dev_post_create,
5615         .tun_dev_attach =               selinux_tun_dev_attach,
5616
5617 #ifdef CONFIG_SECURITY_NETWORK_XFRM
5618         .xfrm_policy_alloc_security =   selinux_xfrm_policy_alloc,
5619         .xfrm_policy_clone_security =   selinux_xfrm_policy_clone,
5620         .xfrm_policy_free_security =    selinux_xfrm_policy_free,
5621         .xfrm_policy_delete_security =  selinux_xfrm_policy_delete,
5622         .xfrm_state_alloc_security =    selinux_xfrm_state_alloc,
5623         .xfrm_state_free_security =     selinux_xfrm_state_free,
5624         .xfrm_state_delete_security =   selinux_xfrm_state_delete,
5625         .xfrm_policy_lookup =           selinux_xfrm_policy_lookup,
5626         .xfrm_state_pol_flow_match =    selinux_xfrm_state_pol_flow_match,
5627         .xfrm_decode_session =          selinux_xfrm_decode_session,
5628 #endif
5629
5630 #ifdef CONFIG_KEYS
5631         .key_alloc =                    selinux_key_alloc,
5632         .key_free =                     selinux_key_free,
5633         .key_permission =               selinux_key_permission,
5634         .key_getsecurity =              selinux_key_getsecurity,
5635 #endif
5636
5637 #ifdef CONFIG_AUDIT
5638         .audit_rule_init =              selinux_audit_rule_init,
5639         .audit_rule_known =             selinux_audit_rule_known,
5640         .audit_rule_match =             selinux_audit_rule_match,
5641         .audit_rule_free =              selinux_audit_rule_free,
5642 #endif
5643 };
5644
5645 static __init int selinux_init(void)
5646 {
5647         if (!security_module_enable(&selinux_ops)) {
5648                 selinux_enabled = 0;
5649                 return 0;
5650         }
5651
5652         if (!selinux_enabled) {
5653                 printk(KERN_INFO "SELinux:  Disabled at boot.\n");
5654                 return 0;
5655         }
5656
5657         printk(KERN_INFO "SELinux:  Initializing.\n");
5658
5659         /* Set the security state for the initial task. */
5660         cred_init_security();
5661
5662         default_noexec = !(VM_DATA_DEFAULT_FLAGS & VM_EXEC);
5663
5664         sel_inode_cache = kmem_cache_create("selinux_inode_security",
5665                                             sizeof(struct inode_security_struct),
5666                                             0, SLAB_PANIC, NULL);
5667         avc_init();
5668
5669         if (register_security(&selinux_ops))
5670                 panic("SELinux: Unable to register with kernel.\n");
5671
5672         if (selinux_enforcing)
5673                 printk(KERN_DEBUG "SELinux:  Starting in enforcing mode\n");
5674         else
5675                 printk(KERN_DEBUG "SELinux:  Starting in permissive mode\n");
5676
5677         return 0;
5678 }
5679
5680 static void delayed_superblock_init(struct super_block *sb, void *unused)
5681 {
5682         superblock_doinit(sb, NULL);
5683 }
5684
5685 void selinux_complete_init(void)
5686 {
5687         printk(KERN_DEBUG "SELinux:  Completing initialization.\n");
5688
5689         /* Set up any superblocks initialized prior to the policy load. */
5690         printk(KERN_DEBUG "SELinux:  Setting up existing superblocks.\n");
5691         iterate_supers(delayed_superblock_init, NULL);
5692 }
5693
5694 /* SELinux requires early initialization in order to label
5695    all processes and objects when they are created. */
5696 security_initcall(selinux_init);
5697
5698 #if defined(CONFIG_NETFILTER)
5699
5700 static struct nf_hook_ops selinux_ipv4_ops[] = {
5701         {
5702                 .hook =         selinux_ipv4_postroute,
5703                 .owner =        THIS_MODULE,
5704                 .pf =           PF_INET,
5705                 .hooknum =      NF_INET_POST_ROUTING,
5706                 .priority =     NF_IP_PRI_SELINUX_LAST,
5707         },
5708         {
5709                 .hook =         selinux_ipv4_forward,
5710                 .owner =        THIS_MODULE,
5711                 .pf =           PF_INET,
5712                 .hooknum =      NF_INET_FORWARD,
5713                 .priority =     NF_IP_PRI_SELINUX_FIRST,
5714         },
5715         {
5716                 .hook =         selinux_ipv4_output,
5717                 .owner =        THIS_MODULE,
5718                 .pf =           PF_INET,
5719                 .hooknum =      NF_INET_LOCAL_OUT,
5720                 .priority =     NF_IP_PRI_SELINUX_FIRST,
5721         }
5722 };
5723
5724 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5725
5726 static struct nf_hook_ops selinux_ipv6_ops[] = {
5727         {
5728                 .hook =         selinux_ipv6_postroute,
5729                 .owner =        THIS_MODULE,
5730                 .pf =           PF_INET6,
5731                 .hooknum =      NF_INET_POST_ROUTING,
5732                 .priority =     NF_IP6_PRI_SELINUX_LAST,
5733         },
5734         {
5735                 .hook =         selinux_ipv6_forward,
5736                 .owner =        THIS_MODULE,
5737                 .pf =           PF_INET6,
5738                 .hooknum =      NF_INET_FORWARD,
5739                 .priority =     NF_IP6_PRI_SELINUX_FIRST,
5740         }
5741 };
5742
5743 #endif  /* IPV6 */
5744
5745 static int __init selinux_nf_ip_init(void)
5746 {
5747         int err = 0;
5748
5749         if (!selinux_enabled)
5750                 goto out;
5751
5752         printk(KERN_DEBUG "SELinux:  Registering netfilter hooks\n");
5753
5754         err = nf_register_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5755         if (err)
5756                 panic("SELinux: nf_register_hooks for IPv4: error %d\n", err);
5757
5758 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5759         err = nf_register_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5760         if (err)
5761                 panic("SELinux: nf_register_hooks for IPv6: error %d\n", err);
5762 #endif  /* IPV6 */
5763
5764 out:
5765         return err;
5766 }
5767
5768 __initcall(selinux_nf_ip_init);
5769
5770 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
5771 static void selinux_nf_ip_exit(void)
5772 {
5773         printk(KERN_DEBUG "SELinux:  Unregistering netfilter hooks\n");
5774
5775         nf_unregister_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5776 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5777         nf_unregister_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5778 #endif  /* IPV6 */
5779 }
5780 #endif
5781
5782 #else /* CONFIG_NETFILTER */
5783
5784 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
5785 #define selinux_nf_ip_exit()
5786 #endif
5787
5788 #endif /* CONFIG_NETFILTER */
5789
5790 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
5791 static int selinux_disabled;
5792
5793 int selinux_disable(void)
5794 {
5795         extern void exit_sel_fs(void);
5796
5797         if (ss_initialized) {
5798                 /* Not permitted after initial policy load. */
5799                 return -EINVAL;
5800         }
5801
5802         if (selinux_disabled) {
5803                 /* Only do this once. */
5804                 return -EINVAL;
5805         }
5806
5807         printk(KERN_INFO "SELinux:  Disabled at runtime.\n");
5808
5809         selinux_disabled = 1;
5810         selinux_enabled = 0;
5811
5812         reset_security_ops();
5813
5814         /* Try to destroy the avc node cache */
5815         avc_disable();
5816
5817         /* Unregister netfilter hooks. */
5818         selinux_nf_ip_exit();
5819
5820         /* Unregister selinuxfs. */
5821         exit_sel_fs();
5822
5823         return 0;
5824 }
5825 #endif