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                 avc_audit(sid, sid, sclass, av, &avd, rc, &ad);
1452         return rc;
1453 }
1454
1455 /* Check whether a task is allowed to use a system operation. */
1456 static int task_has_system(struct task_struct *tsk,
1457                            u32 perms)
1458 {
1459         u32 sid = task_sid(tsk);
1460
1461         return avc_has_perm(sid, SECINITSID_KERNEL,
1462                             SECCLASS_SYSTEM, perms, NULL);
1463 }
1464
1465 /* Check whether a task has a particular permission to an inode.
1466    The 'adp' parameter is optional and allows other audit
1467    data to be passed (e.g. the dentry). */
1468 static int inode_has_perm(const struct cred *cred,
1469                           struct inode *inode,
1470                           u32 perms,
1471                           struct common_audit_data *adp)
1472 {
1473         struct inode_security_struct *isec;
1474         struct common_audit_data ad;
1475         u32 sid;
1476
1477         validate_creds(cred);
1478
1479         if (unlikely(IS_PRIVATE(inode)))
1480                 return 0;
1481
1482         sid = cred_sid(cred);
1483         isec = inode->i_security;
1484
1485         if (!adp) {
1486                 adp = &ad;
1487                 COMMON_AUDIT_DATA_INIT(&ad, FS);
1488                 ad.u.fs.inode = inode;
1489         }
1490
1491         return avc_has_perm(sid, isec->sid, isec->sclass, perms, adp);
1492 }
1493
1494 /* Same as inode_has_perm, but pass explicit audit data containing
1495    the dentry to help the auditing code to more easily generate the
1496    pathname if needed. */
1497 static inline int dentry_has_perm(const struct cred *cred,
1498                                   struct vfsmount *mnt,
1499                                   struct dentry *dentry,
1500                                   u32 av)
1501 {
1502         struct inode *inode = dentry->d_inode;
1503         struct common_audit_data ad;
1504
1505         COMMON_AUDIT_DATA_INIT(&ad, FS);
1506         ad.u.fs.path.mnt = mnt;
1507         ad.u.fs.path.dentry = dentry;
1508         return inode_has_perm(cred, inode, av, &ad);
1509 }
1510
1511 /* Check whether a task can use an open file descriptor to
1512    access an inode in a given way.  Check access to the
1513    descriptor itself, and then use dentry_has_perm to
1514    check a particular permission to the file.
1515    Access to the descriptor is implicitly granted if it
1516    has the same SID as the process.  If av is zero, then
1517    access to the file is not checked, e.g. for cases
1518    where only the descriptor is affected like seek. */
1519 static int file_has_perm(const struct cred *cred,
1520                          struct file *file,
1521                          u32 av)
1522 {
1523         struct file_security_struct *fsec = file->f_security;
1524         struct inode *inode = file->f_path.dentry->d_inode;
1525         struct common_audit_data ad;
1526         u32 sid = cred_sid(cred);
1527         int rc;
1528
1529         COMMON_AUDIT_DATA_INIT(&ad, FS);
1530         ad.u.fs.path = file->f_path;
1531
1532         if (sid != fsec->sid) {
1533                 rc = avc_has_perm(sid, fsec->sid,
1534                                   SECCLASS_FD,
1535                                   FD__USE,
1536                                   &ad);
1537                 if (rc)
1538                         goto out;
1539         }
1540
1541         /* av is zero if only checking access to the descriptor. */
1542         rc = 0;
1543         if (av)
1544                 rc = inode_has_perm(cred, inode, av, &ad);
1545
1546 out:
1547         return rc;
1548 }
1549
1550 /* Check whether a task can create a file. */
1551 static int may_create(struct inode *dir,
1552                       struct dentry *dentry,
1553                       u16 tclass)
1554 {
1555         const struct task_security_struct *tsec = current_security();
1556         struct inode_security_struct *dsec;
1557         struct superblock_security_struct *sbsec;
1558         u32 sid, newsid;
1559         struct common_audit_data ad;
1560         int rc;
1561
1562         dsec = dir->i_security;
1563         sbsec = dir->i_sb->s_security;
1564
1565         sid = tsec->sid;
1566         newsid = tsec->create_sid;
1567
1568         COMMON_AUDIT_DATA_INIT(&ad, FS);
1569         ad.u.fs.path.dentry = dentry;
1570
1571         rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR,
1572                           DIR__ADD_NAME | DIR__SEARCH,
1573                           &ad);
1574         if (rc)
1575                 return rc;
1576
1577         if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
1578                 rc = security_transition_sid(sid, dsec->sid, tclass, NULL, &newsid);
1579                 if (rc)
1580                         return rc;
1581         }
1582
1583         rc = avc_has_perm(sid, newsid, tclass, FILE__CREATE, &ad);
1584         if (rc)
1585                 return rc;
1586
1587         return avc_has_perm(newsid, sbsec->sid,
1588                             SECCLASS_FILESYSTEM,
1589                             FILESYSTEM__ASSOCIATE, &ad);
1590 }
1591
1592 /* Check whether a task can create a key. */
1593 static int may_create_key(u32 ksid,
1594                           struct task_struct *ctx)
1595 {
1596         u32 sid = task_sid(ctx);
1597
1598         return avc_has_perm(sid, ksid, SECCLASS_KEY, KEY__CREATE, NULL);
1599 }
1600
1601 #define MAY_LINK        0
1602 #define MAY_UNLINK      1
1603 #define MAY_RMDIR       2
1604
1605 /* Check whether a task can link, unlink, or rmdir a file/directory. */
1606 static int may_link(struct inode *dir,
1607                     struct dentry *dentry,
1608                     int kind)
1609
1610 {
1611         struct inode_security_struct *dsec, *isec;
1612         struct common_audit_data ad;
1613         u32 sid = current_sid();
1614         u32 av;
1615         int rc;
1616
1617         dsec = dir->i_security;
1618         isec = dentry->d_inode->i_security;
1619
1620         COMMON_AUDIT_DATA_INIT(&ad, FS);
1621         ad.u.fs.path.dentry = dentry;
1622
1623         av = DIR__SEARCH;
1624         av |= (kind ? DIR__REMOVE_NAME : DIR__ADD_NAME);
1625         rc = avc_has_perm(sid, dsec->sid, SECCLASS_DIR, av, &ad);
1626         if (rc)
1627                 return rc;
1628
1629         switch (kind) {
1630         case MAY_LINK:
1631                 av = FILE__LINK;
1632                 break;
1633         case MAY_UNLINK:
1634                 av = FILE__UNLINK;
1635                 break;
1636         case MAY_RMDIR:
1637                 av = DIR__RMDIR;
1638                 break;
1639         default:
1640                 printk(KERN_WARNING "SELinux: %s:  unrecognized kind %d\n",
1641                         __func__, kind);
1642                 return 0;
1643         }
1644
1645         rc = avc_has_perm(sid, isec->sid, isec->sclass, av, &ad);
1646         return rc;
1647 }
1648
1649 static inline int may_rename(struct inode *old_dir,
1650                              struct dentry *old_dentry,
1651                              struct inode *new_dir,
1652                              struct dentry *new_dentry)
1653 {
1654         struct inode_security_struct *old_dsec, *new_dsec, *old_isec, *new_isec;
1655         struct common_audit_data ad;
1656         u32 sid = current_sid();
1657         u32 av;
1658         int old_is_dir, new_is_dir;
1659         int rc;
1660
1661         old_dsec = old_dir->i_security;
1662         old_isec = old_dentry->d_inode->i_security;
1663         old_is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
1664         new_dsec = new_dir->i_security;
1665
1666         COMMON_AUDIT_DATA_INIT(&ad, FS);
1667
1668         ad.u.fs.path.dentry = old_dentry;
1669         rc = avc_has_perm(sid, old_dsec->sid, SECCLASS_DIR,
1670                           DIR__REMOVE_NAME | DIR__SEARCH, &ad);
1671         if (rc)
1672                 return rc;
1673         rc = avc_has_perm(sid, old_isec->sid,
1674                           old_isec->sclass, FILE__RENAME, &ad);
1675         if (rc)
1676                 return rc;
1677         if (old_is_dir && new_dir != old_dir) {
1678                 rc = avc_has_perm(sid, old_isec->sid,
1679                                   old_isec->sclass, DIR__REPARENT, &ad);
1680                 if (rc)
1681                         return rc;
1682         }
1683
1684         ad.u.fs.path.dentry = new_dentry;
1685         av = DIR__ADD_NAME | DIR__SEARCH;
1686         if (new_dentry->d_inode)
1687                 av |= DIR__REMOVE_NAME;
1688         rc = avc_has_perm(sid, new_dsec->sid, SECCLASS_DIR, av, &ad);
1689         if (rc)
1690                 return rc;
1691         if (new_dentry->d_inode) {
1692                 new_isec = new_dentry->d_inode->i_security;
1693                 new_is_dir = S_ISDIR(new_dentry->d_inode->i_mode);
1694                 rc = avc_has_perm(sid, new_isec->sid,
1695                                   new_isec->sclass,
1696                                   (new_is_dir ? DIR__RMDIR : FILE__UNLINK), &ad);
1697                 if (rc)
1698                         return rc;
1699         }
1700
1701         return 0;
1702 }
1703
1704 /* Check whether a task can perform a filesystem operation. */
1705 static int superblock_has_perm(const struct cred *cred,
1706                                struct super_block *sb,
1707                                u32 perms,
1708                                struct common_audit_data *ad)
1709 {
1710         struct superblock_security_struct *sbsec;
1711         u32 sid = cred_sid(cred);
1712
1713         sbsec = sb->s_security;
1714         return avc_has_perm(sid, sbsec->sid, SECCLASS_FILESYSTEM, perms, ad);
1715 }
1716
1717 /* Convert a Linux mode and permission mask to an access vector. */
1718 static inline u32 file_mask_to_av(int mode, int mask)
1719 {
1720         u32 av = 0;
1721
1722         if ((mode & S_IFMT) != S_IFDIR) {
1723                 if (mask & MAY_EXEC)
1724                         av |= FILE__EXECUTE;
1725                 if (mask & MAY_READ)
1726                         av |= FILE__READ;
1727
1728                 if (mask & MAY_APPEND)
1729                         av |= FILE__APPEND;
1730                 else if (mask & MAY_WRITE)
1731                         av |= FILE__WRITE;
1732
1733         } else {
1734                 if (mask & MAY_EXEC)
1735                         av |= DIR__SEARCH;
1736                 if (mask & MAY_WRITE)
1737                         av |= DIR__WRITE;
1738                 if (mask & MAY_READ)
1739                         av |= DIR__READ;
1740         }
1741
1742         return av;
1743 }
1744
1745 /* Convert a Linux file to an access vector. */
1746 static inline u32 file_to_av(struct file *file)
1747 {
1748         u32 av = 0;
1749
1750         if (file->f_mode & FMODE_READ)
1751                 av |= FILE__READ;
1752         if (file->f_mode & FMODE_WRITE) {
1753                 if (file->f_flags & O_APPEND)
1754                         av |= FILE__APPEND;
1755                 else
1756                         av |= FILE__WRITE;
1757         }
1758         if (!av) {
1759                 /*
1760                  * Special file opened with flags 3 for ioctl-only use.
1761                  */
1762                 av = FILE__IOCTL;
1763         }
1764
1765         return av;
1766 }
1767
1768 /*
1769  * Convert a file to an access vector and include the correct open
1770  * open permission.
1771  */
1772 static inline u32 open_file_to_av(struct file *file)
1773 {
1774         u32 av = file_to_av(file);
1775
1776         if (selinux_policycap_openperm)
1777                 av |= FILE__OPEN;
1778
1779         return av;
1780 }
1781
1782 /* Hook functions begin here. */
1783
1784 static int selinux_ptrace_access_check(struct task_struct *child,
1785                                      unsigned int mode)
1786 {
1787         int rc;
1788
1789         rc = cap_ptrace_access_check(child, mode);
1790         if (rc)
1791                 return rc;
1792
1793         if (mode == PTRACE_MODE_READ) {
1794                 u32 sid = current_sid();
1795                 u32 csid = task_sid(child);
1796                 return avc_has_perm(sid, csid, SECCLASS_FILE, FILE__READ, NULL);
1797         }
1798
1799         return current_has_perm(child, PROCESS__PTRACE);
1800 }
1801
1802 static int selinux_ptrace_traceme(struct task_struct *parent)
1803 {
1804         int rc;
1805
1806         rc = cap_ptrace_traceme(parent);
1807         if (rc)
1808                 return rc;
1809
1810         return task_has_perm(parent, current, PROCESS__PTRACE);
1811 }
1812
1813 static int selinux_capget(struct task_struct *target, kernel_cap_t *effective,
1814                           kernel_cap_t *inheritable, kernel_cap_t *permitted)
1815 {
1816         int error;
1817
1818         error = current_has_perm(target, PROCESS__GETCAP);
1819         if (error)
1820                 return error;
1821
1822         return cap_capget(target, effective, inheritable, permitted);
1823 }
1824
1825 static int selinux_capset(struct cred *new, const struct cred *old,
1826                           const kernel_cap_t *effective,
1827                           const kernel_cap_t *inheritable,
1828                           const kernel_cap_t *permitted)
1829 {
1830         int error;
1831
1832         error = cap_capset(new, old,
1833                                       effective, inheritable, permitted);
1834         if (error)
1835                 return error;
1836
1837         return cred_has_perm(old, new, PROCESS__SETCAP);
1838 }
1839
1840 /*
1841  * (This comment used to live with the selinux_task_setuid hook,
1842  * which was removed).
1843  *
1844  * Since setuid only affects the current process, and since the SELinux
1845  * controls are not based on the Linux identity attributes, SELinux does not
1846  * need to control this operation.  However, SELinux does control the use of
1847  * the CAP_SETUID and CAP_SETGID capabilities using the capable hook.
1848  */
1849
1850 static int selinux_capable(struct task_struct *tsk, const struct cred *cred,
1851                            int cap, int audit)
1852 {
1853         int rc;
1854
1855         rc = cap_capable(tsk, cred, cap, audit);
1856         if (rc)
1857                 return rc;
1858
1859         return task_has_capability(tsk, cred, cap, audit);
1860 }
1861
1862 static int selinux_quotactl(int cmds, int type, int id, struct super_block *sb)
1863 {
1864         const struct cred *cred = current_cred();
1865         int rc = 0;
1866
1867         if (!sb)
1868                 return 0;
1869
1870         switch (cmds) {
1871         case Q_SYNC:
1872         case Q_QUOTAON:
1873         case Q_QUOTAOFF:
1874         case Q_SETINFO:
1875         case Q_SETQUOTA:
1876                 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAMOD, NULL);
1877                 break;
1878         case Q_GETFMT:
1879         case Q_GETINFO:
1880         case Q_GETQUOTA:
1881                 rc = superblock_has_perm(cred, sb, FILESYSTEM__QUOTAGET, NULL);
1882                 break;
1883         default:
1884                 rc = 0;  /* let the kernel handle invalid cmds */
1885                 break;
1886         }
1887         return rc;
1888 }
1889
1890 static int selinux_quota_on(struct dentry *dentry)
1891 {
1892         const struct cred *cred = current_cred();
1893
1894         return dentry_has_perm(cred, NULL, dentry, FILE__QUOTAON);
1895 }
1896
1897 static int selinux_syslog(int type)
1898 {
1899         int rc;
1900
1901         switch (type) {
1902         case SYSLOG_ACTION_READ_ALL:    /* Read last kernel messages */
1903         case SYSLOG_ACTION_SIZE_BUFFER: /* Return size of the log buffer */
1904                 rc = task_has_system(current, SYSTEM__SYSLOG_READ);
1905                 break;
1906         case SYSLOG_ACTION_CONSOLE_OFF: /* Disable logging to console */
1907         case SYSLOG_ACTION_CONSOLE_ON:  /* Enable logging to console */
1908         /* Set level of messages printed to console */
1909         case SYSLOG_ACTION_CONSOLE_LEVEL:
1910                 rc = task_has_system(current, SYSTEM__SYSLOG_CONSOLE);
1911                 break;
1912         case SYSLOG_ACTION_CLOSE:       /* Close log */
1913         case SYSLOG_ACTION_OPEN:        /* Open log */
1914         case SYSLOG_ACTION_READ:        /* Read from log */
1915         case SYSLOG_ACTION_READ_CLEAR:  /* Read/clear last kernel messages */
1916         case SYSLOG_ACTION_CLEAR:       /* Clear ring buffer */
1917         default:
1918                 rc = task_has_system(current, SYSTEM__SYSLOG_MOD);
1919                 break;
1920         }
1921         return rc;
1922 }
1923
1924 /*
1925  * Check that a process has enough memory to allocate a new virtual
1926  * mapping. 0 means there is enough memory for the allocation to
1927  * succeed and -ENOMEM implies there is not.
1928  *
1929  * Do not audit the selinux permission check, as this is applied to all
1930  * processes that allocate mappings.
1931  */
1932 static int selinux_vm_enough_memory(struct mm_struct *mm, long pages)
1933 {
1934         int rc, cap_sys_admin = 0;
1935
1936         rc = selinux_capable(current, current_cred(), CAP_SYS_ADMIN,
1937                              SECURITY_CAP_NOAUDIT);
1938         if (rc == 0)
1939                 cap_sys_admin = 1;
1940
1941         return __vm_enough_memory(mm, pages, cap_sys_admin);
1942 }
1943
1944 /* binprm security operations */
1945
1946 static int selinux_bprm_set_creds(struct linux_binprm *bprm)
1947 {
1948         const struct task_security_struct *old_tsec;
1949         struct task_security_struct *new_tsec;
1950         struct inode_security_struct *isec;
1951         struct common_audit_data ad;
1952         struct inode *inode = bprm->file->f_path.dentry->d_inode;
1953         int rc;
1954
1955         rc = cap_bprm_set_creds(bprm);
1956         if (rc)
1957                 return rc;
1958
1959         /* SELinux context only depends on initial program or script and not
1960          * the script interpreter */
1961         if (bprm->cred_prepared)
1962                 return 0;
1963
1964         old_tsec = current_security();
1965         new_tsec = bprm->cred->security;
1966         isec = inode->i_security;
1967
1968         /* Default to the current task SID. */
1969         new_tsec->sid = old_tsec->sid;
1970         new_tsec->osid = old_tsec->sid;
1971
1972         /* Reset fs, key, and sock SIDs on execve. */
1973         new_tsec->create_sid = 0;
1974         new_tsec->keycreate_sid = 0;
1975         new_tsec->sockcreate_sid = 0;
1976
1977         if (old_tsec->exec_sid) {
1978                 new_tsec->sid = old_tsec->exec_sid;
1979                 /* Reset exec SID on execve. */
1980                 new_tsec->exec_sid = 0;
1981         } else {
1982                 /* Check for a default transition on this program. */
1983                 rc = security_transition_sid(old_tsec->sid, isec->sid,
1984                                              SECCLASS_PROCESS, NULL,
1985                                              &new_tsec->sid);
1986                 if (rc)
1987                         return rc;
1988         }
1989
1990         COMMON_AUDIT_DATA_INIT(&ad, FS);
1991         ad.u.fs.path = bprm->file->f_path;
1992
1993         if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID)
1994                 new_tsec->sid = old_tsec->sid;
1995
1996         if (new_tsec->sid == old_tsec->sid) {
1997                 rc = avc_has_perm(old_tsec->sid, isec->sid,
1998                                   SECCLASS_FILE, FILE__EXECUTE_NO_TRANS, &ad);
1999                 if (rc)
2000                         return rc;
2001         } else {
2002                 /* Check permissions for the transition. */
2003                 rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2004                                   SECCLASS_PROCESS, PROCESS__TRANSITION, &ad);
2005                 if (rc)
2006                         return rc;
2007
2008                 rc = avc_has_perm(new_tsec->sid, isec->sid,
2009                                   SECCLASS_FILE, FILE__ENTRYPOINT, &ad);
2010                 if (rc)
2011                         return rc;
2012
2013                 /* Check for shared state */
2014                 if (bprm->unsafe & LSM_UNSAFE_SHARE) {
2015                         rc = avc_has_perm(old_tsec->sid, new_tsec->sid,
2016                                           SECCLASS_PROCESS, PROCESS__SHARE,
2017                                           NULL);
2018                         if (rc)
2019                                 return -EPERM;
2020                 }
2021
2022                 /* Make sure that anyone attempting to ptrace over a task that
2023                  * changes its SID has the appropriate permit */
2024                 if (bprm->unsafe &
2025                     (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
2026                         struct task_struct *tracer;
2027                         struct task_security_struct *sec;
2028                         u32 ptsid = 0;
2029
2030                         rcu_read_lock();
2031                         tracer = tracehook_tracer_task(current);
2032                         if (likely(tracer != NULL)) {
2033                                 sec = __task_cred(tracer)->security;
2034                                 ptsid = sec->sid;
2035                         }
2036                         rcu_read_unlock();
2037
2038                         if (ptsid != 0) {
2039                                 rc = avc_has_perm(ptsid, new_tsec->sid,
2040                                                   SECCLASS_PROCESS,
2041                                                   PROCESS__PTRACE, NULL);
2042                                 if (rc)
2043                                         return -EPERM;
2044                         }
2045                 }
2046
2047                 /* Clear any possibly unsafe personality bits on exec: */
2048                 bprm->per_clear |= PER_CLEAR_ON_SETID;
2049         }
2050
2051         return 0;
2052 }
2053
2054 static int selinux_bprm_secureexec(struct linux_binprm *bprm)
2055 {
2056         const struct task_security_struct *tsec = current_security();
2057         u32 sid, osid;
2058         int atsecure = 0;
2059
2060         sid = tsec->sid;
2061         osid = tsec->osid;
2062
2063         if (osid != sid) {
2064                 /* Enable secure mode for SIDs transitions unless
2065                    the noatsecure permission is granted between
2066                    the two SIDs, i.e. ahp returns 0. */
2067                 atsecure = avc_has_perm(osid, sid,
2068                                         SECCLASS_PROCESS,
2069                                         PROCESS__NOATSECURE, NULL);
2070         }
2071
2072         return (atsecure || cap_bprm_secureexec(bprm));
2073 }
2074
2075 extern struct vfsmount *selinuxfs_mount;
2076 extern struct dentry *selinux_null;
2077
2078 /* Derived from fs/exec.c:flush_old_files. */
2079 static inline void flush_unauthorized_files(const struct cred *cred,
2080                                             struct files_struct *files)
2081 {
2082         struct common_audit_data ad;
2083         struct file *file, *devnull = NULL;
2084         struct tty_struct *tty;
2085         struct fdtable *fdt;
2086         long j = -1;
2087         int drop_tty = 0;
2088
2089         tty = get_current_tty();
2090         if (tty) {
2091                 spin_lock(&tty_files_lock);
2092                 if (!list_empty(&tty->tty_files)) {
2093                         struct tty_file_private *file_priv;
2094                         struct inode *inode;
2095
2096                         /* Revalidate access to controlling tty.
2097                            Use inode_has_perm on the tty inode directly rather
2098                            than using file_has_perm, as this particular open
2099                            file may belong to another process and we are only
2100                            interested in the inode-based check here. */
2101                         file_priv = list_first_entry(&tty->tty_files,
2102                                                 struct tty_file_private, list);
2103                         file = file_priv->file;
2104                         inode = file->f_path.dentry->d_inode;
2105                         if (inode_has_perm(cred, inode,
2106                                            FILE__READ | FILE__WRITE, NULL)) {
2107                                 drop_tty = 1;
2108                         }
2109                 }
2110                 spin_unlock(&tty_files_lock);
2111                 tty_kref_put(tty);
2112         }
2113         /* Reset controlling tty. */
2114         if (drop_tty)
2115                 no_tty();
2116
2117         /* Revalidate access to inherited open files. */
2118
2119         COMMON_AUDIT_DATA_INIT(&ad, FS);
2120
2121         spin_lock(&files->file_lock);
2122         for (;;) {
2123                 unsigned long set, i;
2124                 int fd;
2125
2126                 j++;
2127                 i = j * __NFDBITS;
2128                 fdt = files_fdtable(files);
2129                 if (i >= fdt->max_fds)
2130                         break;
2131                 set = fdt->open_fds->fds_bits[j];
2132                 if (!set)
2133                         continue;
2134                 spin_unlock(&files->file_lock);
2135                 for ( ; set ; i++, set >>= 1) {
2136                         if (set & 1) {
2137                                 file = fget(i);
2138                                 if (!file)
2139                                         continue;
2140                                 if (file_has_perm(cred,
2141                                                   file,
2142                                                   file_to_av(file))) {
2143                                         sys_close(i);
2144                                         fd = get_unused_fd();
2145                                         if (fd != i) {
2146                                                 if (fd >= 0)
2147                                                         put_unused_fd(fd);
2148                                                 fput(file);
2149                                                 continue;
2150                                         }
2151                                         if (devnull) {
2152                                                 get_file(devnull);
2153                                         } else {
2154                                                 devnull = dentry_open(
2155                                                         dget(selinux_null),
2156                                                         mntget(selinuxfs_mount),
2157                                                         O_RDWR, cred);
2158                                                 if (IS_ERR(devnull)) {
2159                                                         devnull = NULL;
2160                                                         put_unused_fd(fd);
2161                                                         fput(file);
2162                                                         continue;
2163                                                 }
2164                                         }
2165                                         fd_install(fd, devnull);
2166                                 }
2167                                 fput(file);
2168                         }
2169                 }
2170                 spin_lock(&files->file_lock);
2171
2172         }
2173         spin_unlock(&files->file_lock);
2174 }
2175
2176 /*
2177  * Prepare a process for imminent new credential changes due to exec
2178  */
2179 static void selinux_bprm_committing_creds(struct linux_binprm *bprm)
2180 {
2181         struct task_security_struct *new_tsec;
2182         struct rlimit *rlim, *initrlim;
2183         int rc, i;
2184
2185         new_tsec = bprm->cred->security;
2186         if (new_tsec->sid == new_tsec->osid)
2187                 return;
2188
2189         /* Close files for which the new task SID is not authorized. */
2190         flush_unauthorized_files(bprm->cred, current->files);
2191
2192         /* Always clear parent death signal on SID transitions. */
2193         current->pdeath_signal = 0;
2194
2195         /* Check whether the new SID can inherit resource limits from the old
2196          * SID.  If not, reset all soft limits to the lower of the current
2197          * task's hard limit and the init task's soft limit.
2198          *
2199          * Note that the setting of hard limits (even to lower them) can be
2200          * controlled by the setrlimit check.  The inclusion of the init task's
2201          * soft limit into the computation is to avoid resetting soft limits
2202          * higher than the default soft limit for cases where the default is
2203          * lower than the hard limit, e.g. RLIMIT_CORE or RLIMIT_STACK.
2204          */
2205         rc = avc_has_perm(new_tsec->osid, new_tsec->sid, SECCLASS_PROCESS,
2206                           PROCESS__RLIMITINH, NULL);
2207         if (rc) {
2208                 /* protect against do_prlimit() */
2209                 task_lock(current);
2210                 for (i = 0; i < RLIM_NLIMITS; i++) {
2211                         rlim = current->signal->rlim + i;
2212                         initrlim = init_task.signal->rlim + i;
2213                         rlim->rlim_cur = min(rlim->rlim_max, initrlim->rlim_cur);
2214                 }
2215                 task_unlock(current);
2216                 update_rlimit_cpu(current, rlimit(RLIMIT_CPU));
2217         }
2218 }
2219
2220 /*
2221  * Clean up the process immediately after the installation of new credentials
2222  * due to exec
2223  */
2224 static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
2225 {
2226         const struct task_security_struct *tsec = current_security();
2227         struct itimerval itimer;
2228         u32 osid, sid;
2229         int rc, i;
2230
2231         osid = tsec->osid;
2232         sid = tsec->sid;
2233
2234         if (sid == osid)
2235                 return;
2236
2237         /* Check whether the new SID can inherit signal state from the old SID.
2238          * If not, clear itimers to avoid subsequent signal generation and
2239          * flush and unblock signals.
2240          *
2241          * This must occur _after_ the task SID has been updated so that any
2242          * kill done after the flush will be checked against the new SID.
2243          */
2244         rc = avc_has_perm(osid, sid, SECCLASS_PROCESS, PROCESS__SIGINH, NULL);
2245         if (rc) {
2246                 memset(&itimer, 0, sizeof itimer);
2247                 for (i = 0; i < 3; i++)
2248                         do_setitimer(i, &itimer, NULL);
2249                 spin_lock_irq(&current->sighand->siglock);
2250                 if (!(current->signal->flags & SIGNAL_GROUP_EXIT)) {
2251                         __flush_signals(current);
2252                         flush_signal_handlers(current, 1);
2253                         sigemptyset(&current->blocked);
2254                 }
2255                 spin_unlock_irq(&current->sighand->siglock);
2256         }
2257
2258         /* Wake up the parent if it is waiting so that it can recheck
2259          * wait permission to the new task SID. */
2260         read_lock(&tasklist_lock);
2261         __wake_up_parent(current, current->real_parent);
2262         read_unlock(&tasklist_lock);
2263 }
2264
2265 /* superblock security operations */
2266
2267 static int selinux_sb_alloc_security(struct super_block *sb)
2268 {
2269         return superblock_alloc_security(sb);
2270 }
2271
2272 static void selinux_sb_free_security(struct super_block *sb)
2273 {
2274         superblock_free_security(sb);
2275 }
2276
2277 static inline int match_prefix(char *prefix, int plen, char *option, int olen)
2278 {
2279         if (plen > olen)
2280                 return 0;
2281
2282         return !memcmp(prefix, option, plen);
2283 }
2284
2285 static inline int selinux_option(char *option, int len)
2286 {
2287         return (match_prefix(CONTEXT_STR, sizeof(CONTEXT_STR)-1, option, len) ||
2288                 match_prefix(FSCONTEXT_STR, sizeof(FSCONTEXT_STR)-1, option, len) ||
2289                 match_prefix(DEFCONTEXT_STR, sizeof(DEFCONTEXT_STR)-1, option, len) ||
2290                 match_prefix(ROOTCONTEXT_STR, sizeof(ROOTCONTEXT_STR)-1, option, len) ||
2291                 match_prefix(LABELSUPP_STR, sizeof(LABELSUPP_STR)-1, option, len));
2292 }
2293
2294 static inline void take_option(char **to, char *from, int *first, int len)
2295 {
2296         if (!*first) {
2297                 **to = ',';
2298                 *to += 1;
2299         } else
2300                 *first = 0;
2301         memcpy(*to, from, len);
2302         *to += len;
2303 }
2304
2305 static inline void take_selinux_option(char **to, char *from, int *first,
2306                                        int len)
2307 {
2308         int current_size = 0;
2309
2310         if (!*first) {
2311                 **to = '|';
2312                 *to += 1;
2313         } else
2314                 *first = 0;
2315
2316         while (current_size < len) {
2317                 if (*from != '"') {
2318                         **to = *from;
2319                         *to += 1;
2320                 }
2321                 from += 1;
2322                 current_size += 1;
2323         }
2324 }
2325
2326 static int selinux_sb_copy_data(char *orig, char *copy)
2327 {
2328         int fnosec, fsec, rc = 0;
2329         char *in_save, *in_curr, *in_end;
2330         char *sec_curr, *nosec_save, *nosec;
2331         int open_quote = 0;
2332
2333         in_curr = orig;
2334         sec_curr = copy;
2335
2336         nosec = (char *)get_zeroed_page(GFP_KERNEL);
2337         if (!nosec) {
2338                 rc = -ENOMEM;
2339                 goto out;
2340         }
2341
2342         nosec_save = nosec;
2343         fnosec = fsec = 1;
2344         in_save = in_end = orig;
2345
2346         do {
2347                 if (*in_end == '"')
2348                         open_quote = !open_quote;
2349                 if ((*in_end == ',' && open_quote == 0) ||
2350                                 *in_end == '\0') {
2351                         int len = in_end - in_curr;
2352
2353                         if (selinux_option(in_curr, len))
2354                                 take_selinux_option(&sec_curr, in_curr, &fsec, len);
2355                         else
2356                                 take_option(&nosec, in_curr, &fnosec, len);
2357
2358                         in_curr = in_end + 1;
2359                 }
2360         } while (*in_end++);
2361
2362         strcpy(in_save, nosec_save);
2363         free_page((unsigned long)nosec_save);
2364 out:
2365         return rc;
2366 }
2367
2368 static int selinux_sb_remount(struct super_block *sb, void *data)
2369 {
2370         int rc, i, *flags;
2371         struct security_mnt_opts opts;
2372         char *secdata, **mount_options;
2373         struct superblock_security_struct *sbsec = sb->s_security;
2374
2375         if (!(sbsec->flags & SE_SBINITIALIZED))
2376                 return 0;
2377
2378         if (!data)
2379                 return 0;
2380
2381         if (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA)
2382                 return 0;
2383
2384         security_init_mnt_opts(&opts);
2385         secdata = alloc_secdata();
2386         if (!secdata)
2387                 return -ENOMEM;
2388         rc = selinux_sb_copy_data(data, secdata);
2389         if (rc)
2390                 goto out_free_secdata;
2391
2392         rc = selinux_parse_opts_str(secdata, &opts);
2393         if (rc)
2394                 goto out_free_secdata;
2395
2396         mount_options = opts.mnt_opts;
2397         flags = opts.mnt_opts_flags;
2398
2399         for (i = 0; i < opts.num_mnt_opts; i++) {
2400                 u32 sid;
2401                 size_t len;
2402
2403                 if (flags[i] == SE_SBLABELSUPP)
2404                         continue;
2405                 len = strlen(mount_options[i]);
2406                 rc = security_context_to_sid(mount_options[i], len, &sid);
2407                 if (rc) {
2408                         printk(KERN_WARNING "SELinux: security_context_to_sid"
2409                                "(%s) failed for (dev %s, type %s) errno=%d\n",
2410                                mount_options[i], sb->s_id, sb->s_type->name, rc);
2411                         goto out_free_opts;
2412                 }
2413                 rc = -EINVAL;
2414                 switch (flags[i]) {
2415                 case FSCONTEXT_MNT:
2416                         if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid, sid))
2417                                 goto out_bad_option;
2418                         break;
2419                 case CONTEXT_MNT:
2420                         if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid, sid))
2421                                 goto out_bad_option;
2422                         break;
2423                 case ROOTCONTEXT_MNT: {
2424                         struct inode_security_struct *root_isec;
2425                         root_isec = sb->s_root->d_inode->i_security;
2426
2427                         if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, sid))
2428                                 goto out_bad_option;
2429                         break;
2430                 }
2431                 case DEFCONTEXT_MNT:
2432                         if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid, sid))
2433                                 goto out_bad_option;
2434                         break;
2435                 default:
2436                         goto out_free_opts;
2437                 }
2438         }
2439
2440         rc = 0;
2441 out_free_opts:
2442         security_free_mnt_opts(&opts);
2443 out_free_secdata:
2444         free_secdata(secdata);
2445         return rc;
2446 out_bad_option:
2447         printk(KERN_WARNING "SELinux: unable to change security options "
2448                "during remount (dev %s, type=%s)\n", sb->s_id,
2449                sb->s_type->name);
2450         goto out_free_opts;
2451 }
2452
2453 static int selinux_sb_kern_mount(struct super_block *sb, int flags, void *data)
2454 {
2455         const struct cred *cred = current_cred();
2456         struct common_audit_data ad;
2457         int rc;
2458
2459         rc = superblock_doinit(sb, data);
2460         if (rc)
2461                 return rc;
2462
2463         /* Allow all mounts performed by the kernel */
2464         if (flags & MS_KERNMOUNT)
2465                 return 0;
2466
2467         COMMON_AUDIT_DATA_INIT(&ad, FS);
2468         ad.u.fs.path.dentry = sb->s_root;
2469         return superblock_has_perm(cred, sb, FILESYSTEM__MOUNT, &ad);
2470 }
2471
2472 static int selinux_sb_statfs(struct dentry *dentry)
2473 {
2474         const struct cred *cred = current_cred();
2475         struct common_audit_data ad;
2476
2477         COMMON_AUDIT_DATA_INIT(&ad, FS);
2478         ad.u.fs.path.dentry = dentry->d_sb->s_root;
2479         return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad);
2480 }
2481
2482 static int selinux_mount(char *dev_name,
2483                          struct path *path,
2484                          char *type,
2485                          unsigned long flags,
2486                          void *data)
2487 {
2488         const struct cred *cred = current_cred();
2489
2490         if (flags & MS_REMOUNT)
2491                 return superblock_has_perm(cred, path->mnt->mnt_sb,
2492                                            FILESYSTEM__REMOUNT, NULL);
2493         else
2494                 return dentry_has_perm(cred, path->mnt, path->dentry,
2495                                        FILE__MOUNTON);
2496 }
2497
2498 static int selinux_umount(struct vfsmount *mnt, int flags)
2499 {
2500         const struct cred *cred = current_cred();
2501
2502         return superblock_has_perm(cred, mnt->mnt_sb,
2503                                    FILESYSTEM__UNMOUNT, NULL);
2504 }
2505
2506 /* inode security operations */
2507
2508 static int selinux_inode_alloc_security(struct inode *inode)
2509 {
2510         return inode_alloc_security(inode);
2511 }
2512
2513 static void selinux_inode_free_security(struct inode *inode)
2514 {
2515         inode_free_security(inode);
2516 }
2517
2518 static int selinux_inode_init_security(struct inode *inode, struct inode *dir,
2519                                        const struct qstr *qstr, char **name,
2520                                        void **value, size_t *len)
2521 {
2522         const struct task_security_struct *tsec = current_security();
2523         struct inode_security_struct *dsec;
2524         struct superblock_security_struct *sbsec;
2525         u32 sid, newsid, clen;
2526         int rc;
2527         char *namep = NULL, *context;
2528
2529         dsec = dir->i_security;
2530         sbsec = dir->i_sb->s_security;
2531
2532         sid = tsec->sid;
2533         newsid = tsec->create_sid;
2534
2535         if ((sbsec->flags & SE_SBINITIALIZED) &&
2536             (sbsec->behavior == SECURITY_FS_USE_MNTPOINT))
2537                 newsid = sbsec->mntpoint_sid;
2538         else if (!newsid || !(sbsec->flags & SE_SBLABELSUPP)) {
2539                 rc = security_transition_sid(sid, dsec->sid,
2540                                              inode_mode_to_security_class(inode->i_mode),
2541                                              qstr, &newsid);
2542                 if (rc) {
2543                         printk(KERN_WARNING "%s:  "
2544                                "security_transition_sid failed, rc=%d (dev=%s "
2545                                "ino=%ld)\n",
2546                                __func__,
2547                                -rc, inode->i_sb->s_id, inode->i_ino);
2548                         return rc;
2549                 }
2550         }
2551
2552         /* Possibly defer initialization to selinux_complete_init. */
2553         if (sbsec->flags & SE_SBINITIALIZED) {
2554                 struct inode_security_struct *isec = inode->i_security;
2555                 isec->sclass = inode_mode_to_security_class(inode->i_mode);
2556                 isec->sid = newsid;
2557                 isec->initialized = 1;
2558         }
2559
2560         if (!ss_initialized || !(sbsec->flags & SE_SBLABELSUPP))
2561                 return -EOPNOTSUPP;
2562
2563         if (name) {
2564                 namep = kstrdup(XATTR_SELINUX_SUFFIX, GFP_NOFS);
2565                 if (!namep)
2566                         return -ENOMEM;
2567                 *name = namep;
2568         }
2569
2570         if (value && len) {
2571                 rc = security_sid_to_context_force(newsid, &context, &clen);
2572                 if (rc) {
2573                         kfree(namep);
2574                         return rc;
2575                 }
2576                 *value = context;
2577                 *len = clen;
2578         }
2579
2580         return 0;
2581 }
2582
2583 static int selinux_inode_create(struct inode *dir, struct dentry *dentry, int mask)
2584 {
2585         return may_create(dir, dentry, SECCLASS_FILE);
2586 }
2587
2588 static int selinux_inode_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2589 {
2590         return may_link(dir, old_dentry, MAY_LINK);
2591 }
2592
2593 static int selinux_inode_unlink(struct inode *dir, struct dentry *dentry)
2594 {
2595         return may_link(dir, dentry, MAY_UNLINK);
2596 }
2597
2598 static int selinux_inode_symlink(struct inode *dir, struct dentry *dentry, const char *name)
2599 {
2600         return may_create(dir, dentry, SECCLASS_LNK_FILE);
2601 }
2602
2603 static int selinux_inode_mkdir(struct inode *dir, struct dentry *dentry, int mask)
2604 {
2605         return may_create(dir, dentry, SECCLASS_DIR);
2606 }
2607
2608 static int selinux_inode_rmdir(struct inode *dir, struct dentry *dentry)
2609 {
2610         return may_link(dir, dentry, MAY_RMDIR);
2611 }
2612
2613 static int selinux_inode_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2614 {
2615         return may_create(dir, dentry, inode_mode_to_security_class(mode));
2616 }
2617
2618 static int selinux_inode_rename(struct inode *old_inode, struct dentry *old_dentry,
2619                                 struct inode *new_inode, struct dentry *new_dentry)
2620 {
2621         return may_rename(old_inode, old_dentry, new_inode, new_dentry);
2622 }
2623
2624 static int selinux_inode_readlink(struct dentry *dentry)
2625 {
2626         const struct cred *cred = current_cred();
2627
2628         return dentry_has_perm(cred, NULL, dentry, FILE__READ);
2629 }
2630
2631 static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *nameidata)
2632 {
2633         const struct cred *cred = current_cred();
2634
2635         return dentry_has_perm(cred, NULL, dentry, FILE__READ);
2636 }
2637
2638 static int selinux_inode_permission(struct inode *inode, int mask)
2639 {
2640         const struct cred *cred = current_cred();
2641         struct common_audit_data ad;
2642         u32 perms;
2643         bool from_access;
2644
2645         from_access = mask & MAY_ACCESS;
2646         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
2647
2648         /* No permission to check.  Existence test. */
2649         if (!mask)
2650                 return 0;
2651
2652         COMMON_AUDIT_DATA_INIT(&ad, FS);
2653         ad.u.fs.inode = inode;
2654
2655         if (from_access)
2656                 ad.selinux_audit_data.auditdeny |= FILE__AUDIT_ACCESS;
2657
2658         perms = file_mask_to_av(inode->i_mode, mask);
2659
2660         return inode_has_perm(cred, inode, perms, &ad);
2661 }
2662
2663 static int selinux_inode_setattr(struct dentry *dentry, struct iattr *iattr)
2664 {
2665         const struct cred *cred = current_cred();
2666         unsigned int ia_valid = iattr->ia_valid;
2667
2668         /* ATTR_FORCE is just used for ATTR_KILL_S[UG]ID. */
2669         if (ia_valid & ATTR_FORCE) {
2670                 ia_valid &= ~(ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_MODE |
2671                               ATTR_FORCE);
2672                 if (!ia_valid)
2673                         return 0;
2674         }
2675
2676         if (ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID |
2677                         ATTR_ATIME_SET | ATTR_MTIME_SET | ATTR_TIMES_SET))
2678                 return dentry_has_perm(cred, NULL, dentry, FILE__SETATTR);
2679
2680         return dentry_has_perm(cred, NULL, dentry, FILE__WRITE);
2681 }
2682
2683 static int selinux_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
2684 {
2685         const struct cred *cred = current_cred();
2686
2687         return dentry_has_perm(cred, mnt, dentry, FILE__GETATTR);
2688 }
2689
2690 static int selinux_inode_setotherxattr(struct dentry *dentry, const char *name)
2691 {
2692         const struct cred *cred = current_cred();
2693
2694         if (!strncmp(name, XATTR_SECURITY_PREFIX,
2695                      sizeof XATTR_SECURITY_PREFIX - 1)) {
2696                 if (!strcmp(name, XATTR_NAME_CAPS)) {
2697                         if (!capable(CAP_SETFCAP))
2698                                 return -EPERM;
2699                 } else if (!capable(CAP_SYS_ADMIN)) {
2700                         /* A different attribute in the security namespace.
2701                            Restrict to administrator. */
2702                         return -EPERM;
2703                 }
2704         }
2705
2706         /* Not an attribute we recognize, so just check the
2707            ordinary setattr permission. */
2708         return dentry_has_perm(cred, NULL, dentry, FILE__SETATTR);
2709 }
2710
2711 static int selinux_inode_setxattr(struct dentry *dentry, const char *name,
2712                                   const void *value, size_t size, int flags)
2713 {
2714         struct inode *inode = dentry->d_inode;
2715         struct inode_security_struct *isec = inode->i_security;
2716         struct superblock_security_struct *sbsec;
2717         struct common_audit_data ad;
2718         u32 newsid, sid = current_sid();
2719         int rc = 0;
2720
2721         if (strcmp(name, XATTR_NAME_SELINUX))
2722                 return selinux_inode_setotherxattr(dentry, name);
2723
2724         sbsec = inode->i_sb->s_security;
2725         if (!(sbsec->flags & SE_SBLABELSUPP))
2726                 return -EOPNOTSUPP;
2727
2728         if (!is_owner_or_cap(inode))
2729                 return -EPERM;
2730
2731         COMMON_AUDIT_DATA_INIT(&ad, FS);
2732         ad.u.fs.path.dentry = dentry;
2733
2734         rc = avc_has_perm(sid, isec->sid, isec->sclass,
2735                           FILE__RELABELFROM, &ad);
2736         if (rc)
2737                 return rc;
2738
2739         rc = security_context_to_sid(value, size, &newsid);
2740         if (rc == -EINVAL) {
2741                 if (!capable(CAP_MAC_ADMIN))
2742                         return rc;
2743                 rc = security_context_to_sid_force(value, size, &newsid);
2744         }
2745         if (rc)
2746                 return rc;
2747
2748         rc = avc_has_perm(sid, newsid, isec->sclass,
2749                           FILE__RELABELTO, &ad);
2750         if (rc)
2751                 return rc;
2752
2753         rc = security_validate_transition(isec->sid, newsid, sid,
2754                                           isec->sclass);
2755         if (rc)
2756                 return rc;
2757
2758         return avc_has_perm(newsid,
2759                             sbsec->sid,
2760                             SECCLASS_FILESYSTEM,
2761                             FILESYSTEM__ASSOCIATE,
2762                             &ad);
2763 }
2764
2765 static void selinux_inode_post_setxattr(struct dentry *dentry, const char *name,
2766                                         const void *value, size_t size,
2767                                         int flags)
2768 {
2769         struct inode *inode = dentry->d_inode;
2770         struct inode_security_struct *isec = inode->i_security;
2771         u32 newsid;
2772         int rc;
2773
2774         if (strcmp(name, XATTR_NAME_SELINUX)) {
2775                 /* Not an attribute we recognize, so nothing to do. */
2776                 return;
2777         }
2778
2779         rc = security_context_to_sid_force(value, size, &newsid);
2780         if (rc) {
2781                 printk(KERN_ERR "SELinux:  unable to map context to SID"
2782                        "for (%s, %lu), rc=%d\n",
2783                        inode->i_sb->s_id, inode->i_ino, -rc);
2784                 return;
2785         }
2786
2787         isec->sid = newsid;
2788         return;
2789 }
2790
2791 static int selinux_inode_getxattr(struct dentry *dentry, const char *name)
2792 {
2793         const struct cred *cred = current_cred();
2794
2795         return dentry_has_perm(cred, NULL, dentry, FILE__GETATTR);
2796 }
2797
2798 static int selinux_inode_listxattr(struct dentry *dentry)
2799 {
2800         const struct cred *cred = current_cred();
2801
2802         return dentry_has_perm(cred, NULL, dentry, FILE__GETATTR);
2803 }
2804
2805 static int selinux_inode_removexattr(struct dentry *dentry, const char *name)
2806 {
2807         if (strcmp(name, XATTR_NAME_SELINUX))
2808                 return selinux_inode_setotherxattr(dentry, name);
2809
2810         /* No one is allowed to remove a SELinux security label.
2811            You can change the label, but all data must be labeled. */
2812         return -EACCES;
2813 }
2814
2815 /*
2816  * Copy the inode security context value to the user.
2817  *
2818  * Permission check is handled by selinux_inode_getxattr hook.
2819  */
2820 static int selinux_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc)
2821 {
2822         u32 size;
2823         int error;
2824         char *context = NULL;
2825         struct inode_security_struct *isec = inode->i_security;
2826
2827         if (strcmp(name, XATTR_SELINUX_SUFFIX))
2828                 return -EOPNOTSUPP;
2829
2830         /*
2831          * If the caller has CAP_MAC_ADMIN, then get the raw context
2832          * value even if it is not defined by current policy; otherwise,
2833          * use the in-core value under current policy.
2834          * Use the non-auditing forms of the permission checks since
2835          * getxattr may be called by unprivileged processes commonly
2836          * and lack of permission just means that we fall back to the
2837          * in-core context value, not a denial.
2838          */
2839         error = selinux_capable(current, current_cred(), CAP_MAC_ADMIN,
2840                                 SECURITY_CAP_NOAUDIT);
2841         if (!error)
2842                 error = security_sid_to_context_force(isec->sid, &context,
2843                                                       &size);
2844         else
2845                 error = security_sid_to_context(isec->sid, &context, &size);
2846         if (error)
2847                 return error;
2848         error = size;
2849         if (alloc) {
2850                 *buffer = context;
2851                 goto out_nofree;
2852         }
2853         kfree(context);
2854 out_nofree:
2855         return error;
2856 }
2857
2858 static int selinux_inode_setsecurity(struct inode *inode, const char *name,
2859                                      const void *value, size_t size, int flags)
2860 {
2861         struct inode_security_struct *isec = inode->i_security;
2862         u32 newsid;
2863         int rc;
2864
2865         if (strcmp(name, XATTR_SELINUX_SUFFIX))
2866                 return -EOPNOTSUPP;
2867
2868         if (!value || !size)
2869                 return -EACCES;
2870
2871         rc = security_context_to_sid((void *)value, size, &newsid);
2872         if (rc)
2873                 return rc;
2874
2875         isec->sid = newsid;
2876         isec->initialized = 1;
2877         return 0;
2878 }
2879
2880 static int selinux_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size)
2881 {
2882         const int len = sizeof(XATTR_NAME_SELINUX);
2883         if (buffer && len <= buffer_size)
2884                 memcpy(buffer, XATTR_NAME_SELINUX, len);
2885         return len;
2886 }
2887
2888 static void selinux_inode_getsecid(const struct inode *inode, u32 *secid)
2889 {
2890         struct inode_security_struct *isec = inode->i_security;
2891         *secid = isec->sid;
2892 }
2893
2894 /* file security operations */
2895
2896 static int selinux_revalidate_file_permission(struct file *file, int mask)
2897 {
2898         const struct cred *cred = current_cred();
2899         struct inode *inode = file->f_path.dentry->d_inode;
2900
2901         /* file_mask_to_av won't add FILE__WRITE if MAY_APPEND is set */
2902         if ((file->f_flags & O_APPEND) && (mask & MAY_WRITE))
2903                 mask |= MAY_APPEND;
2904
2905         return file_has_perm(cred, file,
2906                              file_mask_to_av(inode->i_mode, mask));
2907 }
2908
2909 static int selinux_file_permission(struct file *file, int mask)
2910 {
2911         struct inode *inode = file->f_path.dentry->d_inode;
2912         struct file_security_struct *fsec = file->f_security;
2913         struct inode_security_struct *isec = inode->i_security;
2914         u32 sid = current_sid();
2915
2916         if (!mask)
2917                 /* No permission to check.  Existence test. */
2918                 return 0;
2919
2920         if (sid == fsec->sid && fsec->isid == isec->sid &&
2921             fsec->pseqno == avc_policy_seqno())
2922                 /* No change since dentry_open check. */
2923                 return 0;
2924
2925         return selinux_revalidate_file_permission(file, mask);
2926 }
2927
2928 static int selinux_file_alloc_security(struct file *file)
2929 {
2930         return file_alloc_security(file);
2931 }
2932
2933 static void selinux_file_free_security(struct file *file)
2934 {
2935         file_free_security(file);
2936 }
2937
2938 static int selinux_file_ioctl(struct file *file, unsigned int cmd,
2939                               unsigned long arg)
2940 {
2941         const struct cred *cred = current_cred();
2942         int error = 0;
2943
2944         switch (cmd) {
2945         case FIONREAD:
2946         /* fall through */
2947         case FIBMAP:
2948         /* fall through */
2949         case FIGETBSZ:
2950         /* fall through */
2951         case EXT2_IOC_GETFLAGS:
2952         /* fall through */
2953         case EXT2_IOC_GETVERSION:
2954                 error = file_has_perm(cred, file, FILE__GETATTR);
2955                 break;
2956
2957         case EXT2_IOC_SETFLAGS:
2958         /* fall through */
2959         case EXT2_IOC_SETVERSION:
2960                 error = file_has_perm(cred, file, FILE__SETATTR);
2961                 break;
2962
2963         /* sys_ioctl() checks */
2964         case FIONBIO:
2965         /* fall through */
2966         case FIOASYNC:
2967                 error = file_has_perm(cred, file, 0);
2968                 break;
2969
2970         case KDSKBENT:
2971         case KDSKBSENT:
2972                 error = task_has_capability(current, cred, CAP_SYS_TTY_CONFIG,
2973                                             SECURITY_CAP_AUDIT);
2974                 break;
2975
2976         /* default case assumes that the command will go
2977          * to the file's ioctl() function.
2978          */
2979         default:
2980                 error = file_has_perm(cred, file, FILE__IOCTL);
2981         }
2982         return error;
2983 }
2984
2985 static int default_noexec;
2986
2987 static int file_map_prot_check(struct file *file, unsigned long prot, int shared)
2988 {
2989         const struct cred *cred = current_cred();
2990         int rc = 0;
2991
2992         if (default_noexec &&
2993             (prot & PROT_EXEC) && (!file || (!shared && (prot & PROT_WRITE)))) {
2994                 /*
2995                  * We are making executable an anonymous mapping or a
2996                  * private file mapping that will also be writable.
2997                  * This has an additional check.
2998                  */
2999                 rc = cred_has_perm(cred, cred, PROCESS__EXECMEM);
3000                 if (rc)
3001                         goto error;
3002         }
3003
3004         if (file) {
3005                 /* read access is always possible with a mapping */
3006                 u32 av = FILE__READ;
3007
3008                 /* write access only matters if the mapping is shared */
3009                 if (shared && (prot & PROT_WRITE))
3010                         av |= FILE__WRITE;
3011
3012                 if (prot & PROT_EXEC)
3013                         av |= FILE__EXECUTE;
3014
3015                 return file_has_perm(cred, file, av);
3016         }
3017
3018 error:
3019         return rc;
3020 }
3021
3022 static int selinux_file_mmap(struct file *file, unsigned long reqprot,
3023                              unsigned long prot, unsigned long flags,
3024                              unsigned long addr, unsigned long addr_only)
3025 {
3026         int rc = 0;
3027         u32 sid = current_sid();
3028
3029         /*
3030          * notice that we are intentionally putting the SELinux check before
3031          * the secondary cap_file_mmap check.  This is such a likely attempt
3032          * at bad behaviour/exploit that we always want to get the AVC, even
3033          * if DAC would have also denied the operation.
3034          */
3035         if (addr < CONFIG_LSM_MMAP_MIN_ADDR) {
3036                 rc = avc_has_perm(sid, sid, SECCLASS_MEMPROTECT,
3037                                   MEMPROTECT__MMAP_ZERO, NULL);
3038                 if (rc)
3039                         return rc;
3040         }
3041
3042         /* do DAC check on address space usage */
3043         rc = cap_file_mmap(file, reqprot, prot, flags, addr, addr_only);
3044         if (rc || addr_only)
3045                 return rc;
3046
3047         if (selinux_checkreqprot)
3048                 prot = reqprot;
3049
3050         return file_map_prot_check(file, prot,
3051                                    (flags & MAP_TYPE) == MAP_SHARED);
3052 }
3053
3054 static int selinux_file_mprotect(struct vm_area_struct *vma,
3055                                  unsigned long reqprot,
3056                                  unsigned long prot)
3057 {
3058         const struct cred *cred = current_cred();
3059
3060         if (selinux_checkreqprot)
3061                 prot = reqprot;
3062
3063         if (default_noexec &&
3064             (prot & PROT_EXEC) && !(vma->vm_flags & VM_EXEC)) {
3065                 int rc = 0;
3066                 if (vma->vm_start >= vma->vm_mm->start_brk &&
3067                     vma->vm_end <= vma->vm_mm->brk) {
3068                         rc = cred_has_perm(cred, cred, PROCESS__EXECHEAP);
3069                 } else if (!vma->vm_file &&
3070                            vma->vm_start <= vma->vm_mm->start_stack &&
3071                            vma->vm_end >= vma->vm_mm->start_stack) {
3072                         rc = current_has_perm(current, PROCESS__EXECSTACK);
3073                 } else if (vma->vm_file && vma->anon_vma) {
3074                         /*
3075                          * We are making executable a file mapping that has
3076                          * had some COW done. Since pages might have been
3077                          * written, check ability to execute the possibly
3078                          * modified content.  This typically should only
3079                          * occur for text relocations.
3080                          */
3081                         rc = file_has_perm(cred, vma->vm_file, FILE__EXECMOD);
3082                 }
3083                 if (rc)
3084                         return rc;
3085         }
3086
3087         return file_map_prot_check(vma->vm_file, prot, vma->vm_flags&VM_SHARED);
3088 }
3089
3090 static int selinux_file_lock(struct file *file, unsigned int cmd)
3091 {
3092         const struct cred *cred = current_cred();
3093
3094         return file_has_perm(cred, file, FILE__LOCK);
3095 }
3096
3097 static int selinux_file_fcntl(struct file *file, unsigned int cmd,
3098                               unsigned long arg)
3099 {
3100         const struct cred *cred = current_cred();
3101         int err = 0;
3102
3103         switch (cmd) {
3104         case F_SETFL:
3105                 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3106                         err = -EINVAL;
3107                         break;
3108                 }
3109
3110                 if ((file->f_flags & O_APPEND) && !(arg & O_APPEND)) {
3111                         err = file_has_perm(cred, file, FILE__WRITE);
3112                         break;
3113                 }
3114                 /* fall through */
3115         case F_SETOWN:
3116         case F_SETSIG:
3117         case F_GETFL:
3118         case F_GETOWN:
3119         case F_GETSIG:
3120                 /* Just check FD__USE permission */
3121                 err = file_has_perm(cred, file, 0);
3122                 break;
3123         case F_GETLK:
3124         case F_SETLK:
3125         case F_SETLKW:
3126 #if BITS_PER_LONG == 32
3127         case F_GETLK64:
3128         case F_SETLK64:
3129         case F_SETLKW64:
3130 #endif
3131                 if (!file->f_path.dentry || !file->f_path.dentry->d_inode) {
3132                         err = -EINVAL;
3133                         break;
3134                 }
3135                 err = file_has_perm(cred, file, FILE__LOCK);
3136                 break;
3137         }
3138
3139         return err;
3140 }
3141
3142 static int selinux_file_set_fowner(struct file *file)
3143 {
3144         struct file_security_struct *fsec;
3145
3146         fsec = file->f_security;
3147         fsec->fown_sid = current_sid();
3148
3149         return 0;
3150 }
3151
3152 static int selinux_file_send_sigiotask(struct task_struct *tsk,
3153                                        struct fown_struct *fown, int signum)
3154 {
3155         struct file *file;
3156         u32 sid = task_sid(tsk);
3157         u32 perm;
3158         struct file_security_struct *fsec;
3159
3160         /* struct fown_struct is never outside the context of a struct file */
3161         file = container_of(fown, struct file, f_owner);
3162
3163         fsec = file->f_security;
3164
3165         if (!signum)
3166                 perm = signal_to_av(SIGIO); /* as per send_sigio_to_task */
3167         else
3168                 perm = signal_to_av(signum);
3169
3170         return avc_has_perm(fsec->fown_sid, sid,
3171                             SECCLASS_PROCESS, perm, NULL);
3172 }
3173
3174 static int selinux_file_receive(struct file *file)
3175 {
3176         const struct cred *cred = current_cred();
3177
3178         return file_has_perm(cred, file, file_to_av(file));
3179 }
3180
3181 static int selinux_dentry_open(struct file *file, const struct cred *cred)
3182 {
3183         struct file_security_struct *fsec;
3184         struct inode *inode;
3185         struct inode_security_struct *isec;
3186
3187         inode = file->f_path.dentry->d_inode;
3188         fsec = file->f_security;
3189         isec = inode->i_security;
3190         /*
3191          * Save inode label and policy sequence number
3192          * at open-time so that selinux_file_permission
3193          * can determine whether revalidation is necessary.
3194          * Task label is already saved in the file security
3195          * struct as its SID.
3196          */
3197         fsec->isid = isec->sid;
3198         fsec->pseqno = avc_policy_seqno();
3199         /*
3200          * Since the inode label or policy seqno may have changed
3201          * between the selinux_inode_permission check and the saving
3202          * of state above, recheck that access is still permitted.
3203          * Otherwise, access might never be revalidated against the
3204          * new inode label or new policy.
3205          * This check is not redundant - do not remove.
3206          */
3207         return inode_has_perm(cred, inode, open_file_to_av(file), NULL);
3208 }
3209
3210 /* task security operations */
3211
3212 static int selinux_task_create(unsigned long clone_flags)
3213 {
3214         return current_has_perm(current, PROCESS__FORK);
3215 }
3216
3217 /*
3218  * allocate the SELinux part of blank credentials
3219  */
3220 static int selinux_cred_alloc_blank(struct cred *cred, gfp_t gfp)
3221 {
3222         struct task_security_struct *tsec;
3223
3224         tsec = kzalloc(sizeof(struct task_security_struct), gfp);
3225         if (!tsec)
3226                 return -ENOMEM;
3227
3228         cred->security = tsec;
3229         return 0;
3230 }
3231
3232 /*
3233  * detach and free the LSM part of a set of credentials
3234  */
3235 static void selinux_cred_free(struct cred *cred)
3236 {
3237         struct task_security_struct *tsec = cred->security;
3238
3239         /*
3240          * cred->security == NULL if security_cred_alloc_blank() or
3241          * security_prepare_creds() returned an error.
3242          */
3243         BUG_ON(cred->security && (unsigned long) cred->security < PAGE_SIZE);
3244         cred->security = (void *) 0x7UL;
3245         kfree(tsec);
3246 }
3247
3248 /*
3249  * prepare a new set of credentials for modification
3250  */
3251 static int selinux_cred_prepare(struct cred *new, const struct cred *old,
3252                                 gfp_t gfp)
3253 {
3254         const struct task_security_struct *old_tsec;
3255         struct task_security_struct *tsec;
3256
3257         old_tsec = old->security;
3258
3259         tsec = kmemdup(old_tsec, sizeof(struct task_security_struct), gfp);
3260         if (!tsec)
3261                 return -ENOMEM;
3262
3263         new->security = tsec;
3264         return 0;
3265 }
3266
3267 /*
3268  * transfer the SELinux data to a blank set of creds
3269  */
3270 static void selinux_cred_transfer(struct cred *new, const struct cred *old)
3271 {
3272         const struct task_security_struct *old_tsec = old->security;
3273         struct task_security_struct *tsec = new->security;
3274
3275         *tsec = *old_tsec;
3276 }
3277
3278 /*
3279  * set the security data for a kernel service
3280  * - all the creation contexts are set to unlabelled
3281  */
3282 static int selinux_kernel_act_as(struct cred *new, u32 secid)
3283 {
3284         struct task_security_struct *tsec = new->security;
3285         u32 sid = current_sid();
3286         int ret;
3287
3288         ret = avc_has_perm(sid, secid,
3289                            SECCLASS_KERNEL_SERVICE,
3290                            KERNEL_SERVICE__USE_AS_OVERRIDE,
3291                            NULL);
3292         if (ret == 0) {
3293                 tsec->sid = secid;
3294                 tsec->create_sid = 0;
3295                 tsec->keycreate_sid = 0;
3296                 tsec->sockcreate_sid = 0;
3297         }
3298         return ret;
3299 }
3300
3301 /*
3302  * set the file creation context in a security record to the same as the
3303  * objective context of the specified inode
3304  */
3305 static int selinux_kernel_create_files_as(struct cred *new, struct inode *inode)
3306 {
3307         struct inode_security_struct *isec = inode->i_security;
3308         struct task_security_struct *tsec = new->security;
3309         u32 sid = current_sid();
3310         int ret;
3311
3312         ret = avc_has_perm(sid, isec->sid,
3313                            SECCLASS_KERNEL_SERVICE,
3314                            KERNEL_SERVICE__CREATE_FILES_AS,
3315                            NULL);
3316
3317         if (ret == 0)
3318                 tsec->create_sid = isec->sid;
3319         return ret;
3320 }
3321
3322 static int selinux_kernel_module_request(char *kmod_name)
3323 {
3324         u32 sid;
3325         struct common_audit_data ad;
3326
3327         sid = task_sid(current);
3328
3329         COMMON_AUDIT_DATA_INIT(&ad, KMOD);
3330         ad.u.kmod_name = kmod_name;
3331
3332         return avc_has_perm(sid, SECINITSID_KERNEL, SECCLASS_SYSTEM,
3333                             SYSTEM__MODULE_REQUEST, &ad);
3334 }
3335
3336 static int selinux_task_setpgid(struct task_struct *p, pid_t pgid)
3337 {
3338         return current_has_perm(p, PROCESS__SETPGID);
3339 }
3340
3341 static int selinux_task_getpgid(struct task_struct *p)
3342 {
3343         return current_has_perm(p, PROCESS__GETPGID);
3344 }
3345
3346 static int selinux_task_getsid(struct task_struct *p)
3347 {
3348         return current_has_perm(p, PROCESS__GETSESSION);
3349 }
3350
3351 static void selinux_task_getsecid(struct task_struct *p, u32 *secid)
3352 {
3353         *secid = task_sid(p);
3354 }
3355
3356 static int selinux_task_setnice(struct task_struct *p, int nice)
3357 {
3358         int rc;
3359
3360         rc = cap_task_setnice(p, nice);
3361         if (rc)
3362                 return rc;
3363
3364         return current_has_perm(p, PROCESS__SETSCHED);
3365 }
3366
3367 static int selinux_task_setioprio(struct task_struct *p, int ioprio)
3368 {
3369         int rc;
3370
3371         rc = cap_task_setioprio(p, ioprio);
3372         if (rc)
3373                 return rc;
3374
3375         return current_has_perm(p, PROCESS__SETSCHED);
3376 }
3377
3378 static int selinux_task_getioprio(struct task_struct *p)
3379 {
3380         return current_has_perm(p, PROCESS__GETSCHED);
3381 }
3382
3383 static int selinux_task_setrlimit(struct task_struct *p, unsigned int resource,
3384                 struct rlimit *new_rlim)
3385 {
3386         struct rlimit *old_rlim = p->signal->rlim + resource;
3387
3388         /* Control the ability to change the hard limit (whether
3389            lowering or raising it), so that the hard limit can
3390            later be used as a safe reset point for the soft limit
3391            upon context transitions.  See selinux_bprm_committing_creds. */
3392         if (old_rlim->rlim_max != new_rlim->rlim_max)
3393                 return current_has_perm(p, PROCESS__SETRLIMIT);
3394
3395         return 0;
3396 }
3397
3398 static int selinux_task_setscheduler(struct task_struct *p)
3399 {
3400         int rc;
3401
3402         rc = cap_task_setscheduler(p);
3403         if (rc)
3404                 return rc;
3405
3406         return current_has_perm(p, PROCESS__SETSCHED);
3407 }
3408
3409 static int selinux_task_getscheduler(struct task_struct *p)
3410 {
3411         return current_has_perm(p, PROCESS__GETSCHED);
3412 }
3413
3414 static int selinux_task_movememory(struct task_struct *p)
3415 {
3416         return current_has_perm(p, PROCESS__SETSCHED);
3417 }
3418
3419 static int selinux_task_kill(struct task_struct *p, struct siginfo *info,
3420                                 int sig, u32 secid)
3421 {
3422         u32 perm;
3423         int rc;
3424
3425         if (!sig)
3426                 perm = PROCESS__SIGNULL; /* null signal; existence test */
3427         else
3428                 perm = signal_to_av(sig);
3429         if (secid)
3430                 rc = avc_has_perm(secid, task_sid(p),
3431                                   SECCLASS_PROCESS, perm, NULL);
3432         else
3433                 rc = current_has_perm(p, perm);
3434         return rc;
3435 }
3436
3437 static int selinux_task_wait(struct task_struct *p)
3438 {
3439         return task_has_perm(p, current, PROCESS__SIGCHLD);
3440 }
3441
3442 static void selinux_task_to_inode(struct task_struct *p,
3443                                   struct inode *inode)
3444 {
3445         struct inode_security_struct *isec = inode->i_security;
3446         u32 sid = task_sid(p);
3447
3448         isec->sid = sid;
3449         isec->initialized = 1;
3450 }
3451
3452 /* Returns error only if unable to parse addresses */
3453 static int selinux_parse_skb_ipv4(struct sk_buff *skb,
3454                         struct common_audit_data *ad, u8 *proto)
3455 {
3456         int offset, ihlen, ret = -EINVAL;
3457         struct iphdr _iph, *ih;
3458
3459         offset = skb_network_offset(skb);
3460         ih = skb_header_pointer(skb, offset, sizeof(_iph), &_iph);
3461         if (ih == NULL)
3462                 goto out;
3463
3464         ihlen = ih->ihl * 4;
3465         if (ihlen < sizeof(_iph))
3466                 goto out;
3467
3468         ad->u.net.v4info.saddr = ih->saddr;
3469         ad->u.net.v4info.daddr = ih->daddr;
3470         ret = 0;
3471
3472         if (proto)
3473                 *proto = ih->protocol;
3474
3475         switch (ih->protocol) {
3476         case IPPROTO_TCP: {
3477                 struct tcphdr _tcph, *th;
3478
3479                 if (ntohs(ih->frag_off) & IP_OFFSET)
3480                         break;
3481
3482                 offset += ihlen;
3483                 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3484                 if (th == NULL)
3485                         break;
3486
3487                 ad->u.net.sport = th->source;
3488                 ad->u.net.dport = th->dest;
3489                 break;
3490         }
3491
3492         case IPPROTO_UDP: {
3493                 struct udphdr _udph, *uh;
3494
3495                 if (ntohs(ih->frag_off) & IP_OFFSET)
3496                         break;
3497
3498                 offset += ihlen;
3499                 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3500                 if (uh == NULL)
3501                         break;
3502
3503                 ad->u.net.sport = uh->source;
3504                 ad->u.net.dport = uh->dest;
3505                 break;
3506         }
3507
3508         case IPPROTO_DCCP: {
3509                 struct dccp_hdr _dccph, *dh;
3510
3511                 if (ntohs(ih->frag_off) & IP_OFFSET)
3512                         break;
3513
3514                 offset += ihlen;
3515                 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3516                 if (dh == NULL)
3517                         break;
3518
3519                 ad->u.net.sport = dh->dccph_sport;
3520                 ad->u.net.dport = dh->dccph_dport;
3521                 break;
3522         }
3523
3524         default:
3525                 break;
3526         }
3527 out:
3528         return ret;
3529 }
3530
3531 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3532
3533 /* Returns error only if unable to parse addresses */
3534 static int selinux_parse_skb_ipv6(struct sk_buff *skb,
3535                         struct common_audit_data *ad, u8 *proto)
3536 {
3537         u8 nexthdr;
3538         int ret = -EINVAL, offset;
3539         struct ipv6hdr _ipv6h, *ip6;
3540
3541         offset = skb_network_offset(skb);
3542         ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3543         if (ip6 == NULL)
3544                 goto out;
3545
3546         ipv6_addr_copy(&ad->u.net.v6info.saddr, &ip6->saddr);
3547         ipv6_addr_copy(&ad->u.net.v6info.daddr, &ip6->daddr);
3548         ret = 0;
3549
3550         nexthdr = ip6->nexthdr;
3551         offset += sizeof(_ipv6h);
3552         offset = ipv6_skip_exthdr(skb, offset, &nexthdr);
3553         if (offset < 0)
3554                 goto out;
3555
3556         if (proto)
3557                 *proto = nexthdr;
3558
3559         switch (nexthdr) {
3560         case IPPROTO_TCP: {
3561                 struct tcphdr _tcph, *th;
3562
3563                 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3564                 if (th == NULL)
3565                         break;
3566
3567                 ad->u.net.sport = th->source;
3568                 ad->u.net.dport = th->dest;
3569                 break;
3570         }
3571
3572         case IPPROTO_UDP: {
3573                 struct udphdr _udph, *uh;
3574
3575                 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3576                 if (uh == NULL)
3577                         break;
3578
3579                 ad->u.net.sport = uh->source;
3580                 ad->u.net.dport = uh->dest;
3581                 break;
3582         }
3583
3584         case IPPROTO_DCCP: {
3585                 struct dccp_hdr _dccph, *dh;
3586
3587                 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3588                 if (dh == NULL)
3589                         break;
3590
3591                 ad->u.net.sport = dh->dccph_sport;
3592                 ad->u.net.dport = dh->dccph_dport;
3593                 break;
3594         }
3595
3596         /* includes fragments */
3597         default:
3598                 break;
3599         }
3600 out:
3601         return ret;
3602 }
3603
3604 #endif /* IPV6 */
3605
3606 static int selinux_parse_skb(struct sk_buff *skb, struct common_audit_data *ad,
3607                              char **_addrp, int src, u8 *proto)
3608 {
3609         char *addrp;
3610         int ret;
3611
3612         switch (ad->u.net.family) {
3613         case PF_INET:
3614                 ret = selinux_parse_skb_ipv4(skb, ad, proto);
3615                 if (ret)
3616                         goto parse_error;
3617                 addrp = (char *)(src ? &ad->u.net.v4info.saddr :
3618                                        &ad->u.net.v4info.daddr);
3619                 goto okay;
3620
3621 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
3622         case PF_INET6:
3623                 ret = selinux_parse_skb_ipv6(skb, ad, proto);
3624                 if (ret)
3625                         goto parse_error;
3626                 addrp = (char *)(src ? &ad->u.net.v6info.saddr :
3627                                        &ad->u.net.v6info.daddr);
3628                 goto okay;
3629 #endif  /* IPV6 */
3630         default:
3631                 addrp = NULL;
3632                 goto okay;
3633         }
3634
3635 parse_error:
3636         printk(KERN_WARNING
3637                "SELinux: failure in selinux_parse_skb(),"
3638                " unable to parse packet\n");
3639         return ret;
3640
3641 okay:
3642         if (_addrp)
3643                 *_addrp = addrp;
3644         return 0;
3645 }
3646
3647 /**
3648  * selinux_skb_peerlbl_sid - Determine the peer label of a packet
3649  * @skb: the packet
3650  * @family: protocol family
3651  * @sid: the packet's peer label SID
3652  *
3653  * Description:
3654  * Check the various different forms of network peer labeling and determine
3655  * the peer label/SID for the packet; most of the magic actually occurs in
3656  * the security server function security_net_peersid_cmp().  The function
3657  * returns zero if the value in @sid is valid (although it may be SECSID_NULL)
3658  * or -EACCES if @sid is invalid due to inconsistencies with the different
3659  * peer labels.
3660  *
3661  */
3662 static int selinux_skb_peerlbl_sid(struct sk_buff *skb, u16 family, u32 *sid)
3663 {
3664         int err;
3665         u32 xfrm_sid;
3666         u32 nlbl_sid;
3667         u32 nlbl_type;
3668
3669         selinux_skb_xfrm_sid(skb, &xfrm_sid);
3670         selinux_netlbl_skbuff_getsid(skb, family, &nlbl_type, &nlbl_sid);
3671
3672         err = security_net_peersid_resolve(nlbl_sid, nlbl_type, xfrm_sid, sid);
3673         if (unlikely(err)) {
3674                 printk(KERN_WARNING
3675                        "SELinux: failure in selinux_skb_peerlbl_sid(),"
3676                        " unable to determine packet's peer label\n");
3677                 return -EACCES;
3678         }
3679
3680         return 0;
3681 }
3682
3683 /* socket security operations */
3684
3685 static int socket_sockcreate_sid(const struct task_security_struct *tsec,
3686                                  u16 secclass, u32 *socksid)
3687 {
3688         if (tsec->sockcreate_sid > SECSID_NULL) {
3689                 *socksid = tsec->sockcreate_sid;
3690                 return 0;
3691         }
3692
3693         return security_transition_sid(tsec->sid, tsec->sid, secclass, NULL,
3694                                        socksid);
3695 }
3696
3697 static int sock_has_perm(struct task_struct *task, struct sock *sk, u32 perms)
3698 {
3699         struct sk_security_struct *sksec = sk->sk_security;
3700         struct common_audit_data ad;
3701         u32 tsid = task_sid(task);
3702
3703         if (sksec->sid == SECINITSID_KERNEL)
3704                 return 0;
3705
3706         COMMON_AUDIT_DATA_INIT(&ad, NET);
3707         ad.u.net.sk = sk;
3708
3709         return avc_has_perm(tsid, sksec->sid, sksec->sclass, perms, &ad);
3710 }
3711
3712 static int selinux_socket_create(int family, int type,
3713                                  int protocol, int kern)
3714 {
3715         const struct task_security_struct *tsec = current_security();
3716         u32 newsid;
3717         u16 secclass;
3718         int rc;
3719
3720         if (kern)
3721                 return 0;
3722
3723         secclass = socket_type_to_security_class(family, type, protocol);
3724         rc = socket_sockcreate_sid(tsec, secclass, &newsid);
3725         if (rc)
3726                 return rc;
3727
3728         return avc_has_perm(tsec->sid, newsid, secclass, SOCKET__CREATE, NULL);
3729 }
3730
3731 static int selinux_socket_post_create(struct socket *sock, int family,
3732                                       int type, int protocol, int kern)
3733 {
3734         const struct task_security_struct *tsec = current_security();
3735         struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
3736         struct sk_security_struct *sksec;
3737         int err = 0;
3738
3739         isec->sclass = socket_type_to_security_class(family, type, protocol);
3740
3741         if (kern)
3742                 isec->sid = SECINITSID_KERNEL;
3743         else {
3744                 err = socket_sockcreate_sid(tsec, isec->sclass, &(isec->sid));
3745                 if (err)
3746                         return err;
3747         }
3748
3749         isec->initialized = 1;
3750
3751         if (sock->sk) {
3752                 sksec = sock->sk->sk_security;
3753                 sksec->sid = isec->sid;
3754                 sksec->sclass = isec->sclass;
3755                 err = selinux_netlbl_socket_post_create(sock->sk, family);
3756         }
3757
3758         return err;
3759 }
3760
3761 /* Range of port numbers used to automatically bind.
3762    Need to determine whether we should perform a name_bind
3763    permission check between the socket and the port number. */
3764
3765 static int selinux_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen)
3766 {
3767         struct sock *sk = sock->sk;
3768         u16 family;
3769         int err;
3770
3771         err = sock_has_perm(current, sk, SOCKET__BIND);
3772         if (err)
3773                 goto out;
3774
3775         /*
3776          * If PF_INET or PF_INET6, check name_bind permission for the port.
3777          * Multiple address binding for SCTP is not supported yet: we just
3778          * check the first address now.
3779          */
3780         family = sk->sk_family;
3781         if (family == PF_INET || family == PF_INET6) {
3782                 char *addrp;
3783                 struct sk_security_struct *sksec = sk->sk_security;
3784                 struct common_audit_data ad;
3785                 struct sockaddr_in *addr4 = NULL;
3786                 struct sockaddr_in6 *addr6 = NULL;
3787                 unsigned short snum;
3788                 u32 sid, node_perm;
3789
3790                 if (family == PF_INET) {
3791                         addr4 = (struct sockaddr_in *)address;
3792                         snum = ntohs(addr4->sin_port);
3793                         addrp = (char *)&addr4->sin_addr.s_addr;
3794                 } else {
3795                         addr6 = (struct sockaddr_in6 *)address;
3796                         snum = ntohs(addr6->sin6_port);
3797                         addrp = (char *)&addr6->sin6_addr.s6_addr;
3798                 }
3799
3800                 if (snum) {
3801                         int low, high;
3802
3803                         inet_get_local_port_range(&low, &high);
3804
3805                         if (snum < max(PROT_SOCK, low) || snum > high) {
3806                                 err = sel_netport_sid(sk->sk_protocol,
3807                                                       snum, &sid);
3808                                 if (err)
3809                                         goto out;
3810                                 COMMON_AUDIT_DATA_INIT(&ad, NET);
3811                                 ad.u.net.sport = htons(snum);
3812                                 ad.u.net.family = family;
3813                                 err = avc_has_perm(sksec->sid, sid,
3814                                                    sksec->sclass,
3815                                                    SOCKET__NAME_BIND, &ad);
3816                                 if (err)
3817                                         goto out;
3818                         }
3819                 }
3820
3821                 switch (sksec->sclass) {
3822                 case SECCLASS_TCP_SOCKET:
3823                         node_perm = TCP_SOCKET__NODE_BIND;
3824                         break;
3825
3826                 case SECCLASS_UDP_SOCKET:
3827                         node_perm = UDP_SOCKET__NODE_BIND;
3828                         break;
3829
3830                 case SECCLASS_DCCP_SOCKET:
3831                         node_perm = DCCP_SOCKET__NODE_BIND;
3832                         break;
3833
3834                 default:
3835                         node_perm = RAWIP_SOCKET__NODE_BIND;
3836                         break;
3837                 }
3838
3839                 err = sel_netnode_sid(addrp, family, &sid);
3840                 if (err)
3841                         goto out;
3842
3843                 COMMON_AUDIT_DATA_INIT(&ad, NET);
3844                 ad.u.net.sport = htons(snum);
3845                 ad.u.net.family = family;
3846
3847                 if (family == PF_INET)
3848                         ad.u.net.v4info.saddr = addr4->sin_addr.s_addr;
3849                 else
3850                         ipv6_addr_copy(&ad.u.net.v6info.saddr, &addr6->sin6_addr);
3851
3852                 err = avc_has_perm(sksec->sid, sid,
3853                                    sksec->sclass, node_perm, &ad);
3854                 if (err)
3855                         goto out;
3856         }
3857 out:
3858         return err;
3859 }
3860
3861 static int selinux_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen)
3862 {
3863         struct sock *sk = sock->sk;
3864         struct sk_security_struct *sksec = sk->sk_security;
3865         int err;
3866
3867         err = sock_has_perm(current, sk, SOCKET__CONNECT);
3868         if (err)
3869                 return err;
3870
3871         /*
3872          * If a TCP or DCCP socket, check name_connect permission for the port.
3873          */
3874         if (sksec->sclass == SECCLASS_TCP_SOCKET ||
3875             sksec->sclass == SECCLASS_DCCP_SOCKET) {
3876                 struct common_audit_data ad;
3877                 struct sockaddr_in *addr4 = NULL;
3878                 struct sockaddr_in6 *addr6 = NULL;
3879                 unsigned short snum;
3880                 u32 sid, perm;
3881
3882                 if (sk->sk_family == PF_INET) {
3883                         addr4 = (struct sockaddr_in *)address;
3884                         if (addrlen < sizeof(struct sockaddr_in))
3885                                 return -EINVAL;
3886                         snum = ntohs(addr4->sin_port);
3887                 } else {
3888                         addr6 = (struct sockaddr_in6 *)address;
3889                         if (addrlen < SIN6_LEN_RFC2133)
3890                                 return -EINVAL;
3891                         snum = ntohs(addr6->sin6_port);
3892                 }
3893
3894                 err = sel_netport_sid(sk->sk_protocol, snum, &sid);
3895                 if (err)
3896                         goto out;
3897
3898                 perm = (sksec->sclass == SECCLASS_TCP_SOCKET) ?
3899                        TCP_SOCKET__NAME_CONNECT : DCCP_SOCKET__NAME_CONNECT;
3900
3901                 COMMON_AUDIT_DATA_INIT(&ad, NET);
3902                 ad.u.net.dport = htons(snum);
3903                 ad.u.net.family = sk->sk_family;
3904                 err = avc_has_perm(sksec->sid, sid, sksec->sclass, perm, &ad);
3905                 if (err)
3906                         goto out;
3907         }
3908
3909         err = selinux_netlbl_socket_connect(sk, address);
3910
3911 out:
3912         return err;
3913 }
3914
3915 static int selinux_socket_listen(struct socket *sock, int backlog)
3916 {
3917         return sock_has_perm(current, sock->sk, SOCKET__LISTEN);
3918 }
3919
3920 static int selinux_socket_accept(struct socket *sock, struct socket *newsock)
3921 {
3922         int err;
3923         struct inode_security_struct *isec;
3924         struct inode_security_struct *newisec;
3925
3926         err = sock_has_perm(current, sock->sk, SOCKET__ACCEPT);
3927         if (err)
3928                 return err;
3929
3930         newisec = SOCK_INODE(newsock)->i_security;
3931
3932         isec = SOCK_INODE(sock)->i_security;
3933         newisec->sclass = isec->sclass;
3934         newisec->sid = isec->sid;
3935         newisec->initialized = 1;
3936
3937         return 0;
3938 }
3939
3940 static int selinux_socket_sendmsg(struct socket *sock, struct msghdr *msg,
3941                                   int size)
3942 {
3943         return sock_has_perm(current, sock->sk, SOCKET__WRITE);
3944 }
3945
3946 static int selinux_socket_recvmsg(struct socket *sock, struct msghdr *msg,
3947                                   int size, int flags)
3948 {
3949         return sock_has_perm(current, sock->sk, SOCKET__READ);
3950 }
3951
3952 static int selinux_socket_getsockname(struct socket *sock)
3953 {
3954         return sock_has_perm(current, sock->sk, SOCKET__GETATTR);
3955 }
3956
3957 static int selinux_socket_getpeername(struct socket *sock)
3958 {
3959         return sock_has_perm(current, sock->sk, SOCKET__GETATTR);
3960 }
3961
3962 static int selinux_socket_setsockopt(struct socket *sock, int level, int optname)
3963 {
3964         int err;
3965
3966         err = sock_has_perm(current, sock->sk, SOCKET__SETOPT);
3967         if (err)
3968                 return err;
3969
3970         return selinux_netlbl_socket_setsockopt(sock, level, optname);
3971 }
3972
3973 static int selinux_socket_getsockopt(struct socket *sock, int level,
3974                                      int optname)
3975 {
3976         return sock_has_perm(current, sock->sk, SOCKET__GETOPT);
3977 }
3978
3979 static int selinux_socket_shutdown(struct socket *sock, int how)
3980 {
3981         return sock_has_perm(current, sock->sk, SOCKET__SHUTDOWN);
3982 }
3983
3984 static int selinux_socket_unix_stream_connect(struct sock *sock,
3985                                               struct sock *other,
3986                                               struct sock *newsk)
3987 {
3988         struct sk_security_struct *sksec_sock = sock->sk_security;
3989         struct sk_security_struct *sksec_other = other->sk_security;
3990         struct sk_security_struct *sksec_new = newsk->sk_security;
3991         struct common_audit_data ad;
3992         int err;
3993
3994         COMMON_AUDIT_DATA_INIT(&ad, NET);
3995         ad.u.net.sk = other;
3996
3997         err = avc_has_perm(sksec_sock->sid, sksec_other->sid,
3998                            sksec_other->sclass,
3999                            UNIX_STREAM_SOCKET__CONNECTTO, &ad);
4000         if (err)
4001                 return err;
4002
4003         /* server child socket */
4004         sksec_new->peer_sid = sksec_sock->sid;
4005         err = security_sid_mls_copy(sksec_other->sid, sksec_sock->sid,
4006                                     &sksec_new->sid);
4007         if (err)
4008                 return err;
4009
4010         /* connecting socket */
4011         sksec_sock->peer_sid = sksec_new->sid;
4012
4013         return 0;
4014 }
4015
4016 static int selinux_socket_unix_may_send(struct socket *sock,
4017                                         struct socket *other)
4018 {
4019         struct sk_security_struct *ssec = sock->sk->sk_security;
4020         struct sk_security_struct *osec = other->sk->sk_security;
4021         struct common_audit_data ad;
4022
4023         COMMON_AUDIT_DATA_INIT(&ad, NET);
4024         ad.u.net.sk = other->sk;
4025
4026         return avc_has_perm(ssec->sid, osec->sid, osec->sclass, SOCKET__SENDTO,
4027                             &ad);
4028 }
4029
4030 static int selinux_inet_sys_rcv_skb(int ifindex, char *addrp, u16 family,
4031                                     u32 peer_sid,
4032                                     struct common_audit_data *ad)
4033 {
4034         int err;
4035         u32 if_sid;
4036         u32 node_sid;
4037
4038         err = sel_netif_sid(ifindex, &if_sid);
4039         if (err)
4040                 return err;
4041         err = avc_has_perm(peer_sid, if_sid,
4042                            SECCLASS_NETIF, NETIF__INGRESS, ad);
4043         if (err)
4044                 return err;
4045
4046         err = sel_netnode_sid(addrp, family, &node_sid);
4047         if (err)
4048                 return err;
4049         return avc_has_perm(peer_sid, node_sid,
4050                             SECCLASS_NODE, NODE__RECVFROM, ad);
4051 }
4052
4053 static int selinux_sock_rcv_skb_compat(struct sock *sk, struct sk_buff *skb,
4054                                        u16 family)
4055 {
4056         int err = 0;
4057         struct sk_security_struct *sksec = sk->sk_security;
4058         u32 sk_sid = sksec->sid;
4059         struct common_audit_data ad;
4060         char *addrp;
4061
4062         COMMON_AUDIT_DATA_INIT(&ad, NET);
4063         ad.u.net.netif = skb->skb_iif;
4064         ad.u.net.family = family;
4065         err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4066         if (err)
4067                 return err;
4068
4069         if (selinux_secmark_enabled()) {
4070                 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4071                                    PACKET__RECV, &ad);
4072                 if (err)
4073                         return err;
4074         }
4075
4076         err = selinux_netlbl_sock_rcv_skb(sksec, skb, family, &ad);
4077         if (err)
4078                 return err;
4079         err = selinux_xfrm_sock_rcv_skb(sksec->sid, skb, &ad);
4080
4081         return err;
4082 }
4083
4084 static int selinux_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
4085 {
4086         int err;
4087         struct sk_security_struct *sksec = sk->sk_security;
4088         u16 family = sk->sk_family;
4089         u32 sk_sid = sksec->sid;
4090         struct common_audit_data ad;
4091         char *addrp;
4092         u8 secmark_active;
4093         u8 peerlbl_active;
4094
4095         if (family != PF_INET && family != PF_INET6)
4096                 return 0;
4097
4098         /* Handle mapped IPv4 packets arriving via IPv6 sockets */
4099         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4100                 family = PF_INET;
4101
4102         /* If any sort of compatibility mode is enabled then handoff processing
4103          * to the selinux_sock_rcv_skb_compat() function to deal with the
4104          * special handling.  We do this in an attempt to keep this function
4105          * as fast and as clean as possible. */
4106         if (!selinux_policycap_netpeer)
4107                 return selinux_sock_rcv_skb_compat(sk, skb, family);
4108
4109         secmark_active = selinux_secmark_enabled();
4110         peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4111         if (!secmark_active && !peerlbl_active)
4112                 return 0;
4113
4114         COMMON_AUDIT_DATA_INIT(&ad, NET);
4115         ad.u.net.netif = skb->skb_iif;
4116         ad.u.net.family = family;
4117         err = selinux_parse_skb(skb, &ad, &addrp, 1, NULL);
4118         if (err)
4119                 return err;
4120
4121         if (peerlbl_active) {
4122                 u32 peer_sid;
4123
4124                 err = selinux_skb_peerlbl_sid(skb, family, &peer_sid);
4125                 if (err)
4126                         return err;
4127                 err = selinux_inet_sys_rcv_skb(skb->skb_iif, addrp, family,
4128                                                peer_sid, &ad);
4129                 if (err) {
4130                         selinux_netlbl_err(skb, err, 0);
4131                         return err;
4132                 }
4133                 err = avc_has_perm(sk_sid, peer_sid, SECCLASS_PEER,
4134                                    PEER__RECV, &ad);
4135                 if (err)
4136                         selinux_netlbl_err(skb, err, 0);
4137         }
4138
4139         if (secmark_active) {
4140                 err = avc_has_perm(sk_sid, skb->secmark, SECCLASS_PACKET,
4141                                    PACKET__RECV, &ad);
4142                 if (err)
4143                         return err;
4144         }
4145
4146         return err;
4147 }
4148
4149 static int selinux_socket_getpeersec_stream(struct socket *sock, char __user *optval,
4150                                             int __user *optlen, unsigned len)
4151 {
4152         int err = 0;
4153         char *scontext;
4154         u32 scontext_len;
4155         struct sk_security_struct *sksec = sock->sk->sk_security;
4156         u32 peer_sid = SECSID_NULL;
4157
4158         if (sksec->sclass == SECCLASS_UNIX_STREAM_SOCKET ||
4159             sksec->sclass == SECCLASS_TCP_SOCKET)
4160                 peer_sid = sksec->peer_sid;
4161         if (peer_sid == SECSID_NULL)
4162                 return -ENOPROTOOPT;
4163
4164         err = security_sid_to_context(peer_sid, &scontext, &scontext_len);
4165         if (err)
4166                 return err;
4167
4168         if (scontext_len > len) {
4169                 err = -ERANGE;
4170                 goto out_len;
4171         }
4172
4173         if (copy_to_user(optval, scontext, scontext_len))
4174                 err = -EFAULT;
4175
4176 out_len:
4177         if (put_user(scontext_len, optlen))
4178                 err = -EFAULT;
4179         kfree(scontext);
4180         return err;
4181 }
4182
4183 static int selinux_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid)
4184 {
4185         u32 peer_secid = SECSID_NULL;
4186         u16 family;
4187
4188         if (skb && skb->protocol == htons(ETH_P_IP))
4189                 family = PF_INET;
4190         else if (skb && skb->protocol == htons(ETH_P_IPV6))
4191                 family = PF_INET6;
4192         else if (sock)
4193                 family = sock->sk->sk_family;
4194         else
4195                 goto out;
4196
4197         if (sock && family == PF_UNIX)
4198                 selinux_inode_getsecid(SOCK_INODE(sock), &peer_secid);
4199         else if (skb)
4200                 selinux_skb_peerlbl_sid(skb, family, &peer_secid);
4201
4202 out:
4203         *secid = peer_secid;
4204         if (peer_secid == SECSID_NULL)
4205                 return -EINVAL;
4206         return 0;
4207 }
4208
4209 static int selinux_sk_alloc_security(struct sock *sk, int family, gfp_t priority)
4210 {
4211         struct sk_security_struct *sksec;
4212
4213         sksec = kzalloc(sizeof(*sksec), priority);
4214         if (!sksec)
4215                 return -ENOMEM;
4216
4217         sksec->peer_sid = SECINITSID_UNLABELED;
4218         sksec->sid = SECINITSID_UNLABELED;
4219         selinux_netlbl_sk_security_reset(sksec);
4220         sk->sk_security = sksec;
4221
4222         return 0;
4223 }
4224
4225 static void selinux_sk_free_security(struct sock *sk)
4226 {
4227         struct sk_security_struct *sksec = sk->sk_security;
4228
4229         sk->sk_security = NULL;
4230         selinux_netlbl_sk_security_free(sksec);
4231         kfree(sksec);
4232 }
4233
4234 static void selinux_sk_clone_security(const struct sock *sk, struct sock *newsk)
4235 {
4236         struct sk_security_struct *sksec = sk->sk_security;
4237         struct sk_security_struct *newsksec = newsk->sk_security;
4238
4239         newsksec->sid = sksec->sid;
4240         newsksec->peer_sid = sksec->peer_sid;
4241         newsksec->sclass = sksec->sclass;
4242
4243         selinux_netlbl_sk_security_reset(newsksec);
4244 }
4245
4246 static void selinux_sk_getsecid(struct sock *sk, u32 *secid)
4247 {
4248         if (!sk)
4249                 *secid = SECINITSID_ANY_SOCKET;
4250         else {
4251                 struct sk_security_struct *sksec = sk->sk_security;
4252
4253                 *secid = sksec->sid;
4254         }
4255 }
4256
4257 static void selinux_sock_graft(struct sock *sk, struct socket *parent)
4258 {
4259         struct inode_security_struct *isec = SOCK_INODE(parent)->i_security;
4260         struct sk_security_struct *sksec = sk->sk_security;
4261
4262         if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6 ||
4263             sk->sk_family == PF_UNIX)
4264                 isec->sid = sksec->sid;
4265         sksec->sclass = isec->sclass;
4266 }
4267
4268 static int selinux_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4269                                      struct request_sock *req)
4270 {
4271         struct sk_security_struct *sksec = sk->sk_security;
4272         int err;
4273         u16 family = sk->sk_family;
4274         u32 newsid;
4275         u32 peersid;
4276
4277         /* handle mapped IPv4 packets arriving via IPv6 sockets */
4278         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4279                 family = PF_INET;
4280
4281         err = selinux_skb_peerlbl_sid(skb, family, &peersid);
4282         if (err)
4283                 return err;
4284         if (peersid == SECSID_NULL) {
4285                 req->secid = sksec->sid;
4286                 req->peer_secid = SECSID_NULL;
4287         } else {
4288                 err = security_sid_mls_copy(sksec->sid, peersid, &newsid);
4289                 if (err)
4290                         return err;
4291                 req->secid = newsid;
4292                 req->peer_secid = peersid;
4293         }
4294
4295         return selinux_netlbl_inet_conn_request(req, family);
4296 }
4297
4298 static void selinux_inet_csk_clone(struct sock *newsk,
4299                                    const struct request_sock *req)
4300 {
4301         struct sk_security_struct *newsksec = newsk->sk_security;
4302
4303         newsksec->sid = req->secid;
4304         newsksec->peer_sid = req->peer_secid;
4305         /* NOTE: Ideally, we should also get the isec->sid for the
4306            new socket in sync, but we don't have the isec available yet.
4307            So we will wait until sock_graft to do it, by which
4308            time it will have been created and available. */
4309
4310         /* We don't need to take any sort of lock here as we are the only
4311          * thread with access to newsksec */
4312         selinux_netlbl_inet_csk_clone(newsk, req->rsk_ops->family);
4313 }
4314
4315 static void selinux_inet_conn_established(struct sock *sk, struct sk_buff *skb)
4316 {
4317         u16 family = sk->sk_family;
4318         struct sk_security_struct *sksec = sk->sk_security;
4319
4320         /* handle mapped IPv4 packets arriving via IPv6 sockets */
4321         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
4322                 family = PF_INET;
4323
4324         selinux_skb_peerlbl_sid(skb, family, &sksec->peer_sid);
4325 }
4326
4327 static int selinux_secmark_relabel_packet(u32 sid)
4328 {
4329         const struct task_security_struct *__tsec;
4330         u32 tsid;
4331
4332         __tsec = current_security();
4333         tsid = __tsec->sid;
4334
4335         return avc_has_perm(tsid, sid, SECCLASS_PACKET, PACKET__RELABELTO, NULL);
4336 }
4337
4338 static void selinux_secmark_refcount_inc(void)
4339 {
4340         atomic_inc(&selinux_secmark_refcount);
4341 }
4342
4343 static void selinux_secmark_refcount_dec(void)
4344 {
4345         atomic_dec(&selinux_secmark_refcount);
4346 }
4347
4348 static void selinux_req_classify_flow(const struct request_sock *req,
4349                                       struct flowi *fl)
4350 {
4351         fl->secid = req->secid;
4352 }
4353
4354 static int selinux_tun_dev_create(void)
4355 {
4356         u32 sid = current_sid();
4357
4358         /* we aren't taking into account the "sockcreate" SID since the socket
4359          * that is being created here is not a socket in the traditional sense,
4360          * instead it is a private sock, accessible only to the kernel, and
4361          * representing a wide range of network traffic spanning multiple
4362          * connections unlike traditional sockets - check the TUN driver to
4363          * get a better understanding of why this socket is special */
4364
4365         return avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET, TUN_SOCKET__CREATE,
4366                             NULL);
4367 }
4368
4369 static void selinux_tun_dev_post_create(struct sock *sk)
4370 {
4371         struct sk_security_struct *sksec = sk->sk_security;
4372
4373         /* we don't currently perform any NetLabel based labeling here and it
4374          * isn't clear that we would want to do so anyway; while we could apply
4375          * labeling without the support of the TUN user the resulting labeled
4376          * traffic from the other end of the connection would almost certainly
4377          * cause confusion to the TUN user that had no idea network labeling
4378          * protocols were being used */
4379
4380         /* see the comments in selinux_tun_dev_create() about why we don't use
4381          * the sockcreate SID here */
4382
4383         sksec->sid = current_sid();
4384         sksec->sclass = SECCLASS_TUN_SOCKET;
4385 }
4386
4387 static int selinux_tun_dev_attach(struct sock *sk)
4388 {
4389         struct sk_security_struct *sksec = sk->sk_security;
4390         u32 sid = current_sid();
4391         int err;
4392
4393         err = avc_has_perm(sid, sksec->sid, SECCLASS_TUN_SOCKET,
4394                            TUN_SOCKET__RELABELFROM, NULL);
4395         if (err)
4396                 return err;
4397         err = avc_has_perm(sid, sid, SECCLASS_TUN_SOCKET,
4398                            TUN_SOCKET__RELABELTO, NULL);
4399         if (err)
4400                 return err;
4401
4402         sksec->sid = sid;
4403
4404         return 0;
4405 }
4406
4407 static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb)
4408 {
4409         int err = 0;
4410         u32 perm;
4411         struct nlmsghdr *nlh;
4412         struct sk_security_struct *sksec = sk->sk_security;
4413
4414         if (skb->len < NLMSG_SPACE(0)) {
4415                 err = -EINVAL;
4416                 goto out;
4417         }
4418         nlh = nlmsg_hdr(skb);
4419
4420         err = selinux_nlmsg_lookup(sksec->sclass, nlh->nlmsg_type, &perm);
4421         if (err) {
4422                 if (err == -EINVAL) {
4423                         audit_log(current->audit_context, GFP_KERNEL, AUDIT_SELINUX_ERR,
4424                                   "SELinux:  unrecognized netlink message"
4425                                   " type=%hu for sclass=%hu\n",
4426                                   nlh->nlmsg_type, sksec->sclass);
4427                         if (!selinux_enforcing || security_get_allow_unknown())
4428                                 err = 0;
4429                 }
4430
4431                 /* Ignore */
4432                 if (err == -ENOENT)
4433                         err = 0;
4434                 goto out;
4435         }
4436
4437         err = sock_has_perm(current, sk, perm);
4438 out:
4439         return err;
4440 }
4441
4442 #ifdef CONFIG_NETFILTER
4443
4444 static unsigned int selinux_ip_forward(struct sk_buff *skb, int ifindex,
4445                                        u16 family)
4446 {
4447         int err;
4448         char *addrp;
4449         u32 peer_sid;
4450         struct common_audit_data ad;
4451         u8 secmark_active;
4452         u8 netlbl_active;
4453         u8 peerlbl_active;
4454
4455         if (!selinux_policycap_netpeer)
4456                 return NF_ACCEPT;
4457
4458         secmark_active = selinux_secmark_enabled();
4459         netlbl_active = netlbl_enabled();
4460         peerlbl_active = netlbl_active || selinux_xfrm_enabled();
4461         if (!secmark_active && !peerlbl_active)
4462                 return NF_ACCEPT;
4463
4464         if (selinux_skb_peerlbl_sid(skb, family, &peer_sid) != 0)
4465                 return NF_DROP;
4466
4467         COMMON_AUDIT_DATA_INIT(&ad, NET);
4468         ad.u.net.netif = ifindex;
4469         ad.u.net.family = family;
4470         if (selinux_parse_skb(skb, &ad, &addrp, 1, NULL) != 0)
4471                 return NF_DROP;
4472
4473         if (peerlbl_active) {
4474                 err = selinux_inet_sys_rcv_skb(ifindex, addrp, family,
4475                                                peer_sid, &ad);
4476                 if (err) {
4477                         selinux_netlbl_err(skb, err, 1);
4478                         return NF_DROP;
4479                 }
4480         }
4481
4482         if (secmark_active)
4483                 if (avc_has_perm(peer_sid, skb->secmark,
4484                                  SECCLASS_PACKET, PACKET__FORWARD_IN, &ad))
4485                         return NF_DROP;
4486
4487         if (netlbl_active)
4488                 /* we do this in the FORWARD path and not the POST_ROUTING
4489                  * path because we want to make sure we apply the necessary
4490                  * labeling before IPsec is applied so we can leverage AH
4491                  * protection */
4492                 if (selinux_netlbl_skbuff_setsid(skb, family, peer_sid) != 0)
4493                         return NF_DROP;
4494
4495         return NF_ACCEPT;
4496 }
4497
4498 static unsigned int selinux_ipv4_forward(unsigned int hooknum,
4499                                          struct sk_buff *skb,
4500                                          const struct net_device *in,
4501                                          const struct net_device *out,
4502                                          int (*okfn)(struct sk_buff *))
4503 {
4504         return selinux_ip_forward(skb, in->ifindex, PF_INET);
4505 }
4506
4507 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4508 static unsigned int selinux_ipv6_forward(unsigned int hooknum,
4509                                          struct sk_buff *skb,
4510                                          const struct net_device *in,
4511                                          const struct net_device *out,
4512                                          int (*okfn)(struct sk_buff *))
4513 {
4514         return selinux_ip_forward(skb, in->ifindex, PF_INET6);
4515 }
4516 #endif  /* IPV6 */
4517
4518 static unsigned int selinux_ip_output(struct sk_buff *skb,
4519                                       u16 family)
4520 {
4521         u32 sid;
4522
4523         if (!netlbl_enabled())
4524                 return NF_ACCEPT;
4525
4526         /* we do this in the LOCAL_OUT path and not the POST_ROUTING path
4527          * because we want to make sure we apply the necessary labeling
4528          * before IPsec is applied so we can leverage AH protection */
4529         if (skb->sk) {
4530                 struct sk_security_struct *sksec = skb->sk->sk_security;
4531                 sid = sksec->sid;
4532         } else
4533                 sid = SECINITSID_KERNEL;
4534         if (selinux_netlbl_skbuff_setsid(skb, family, sid) != 0)
4535                 return NF_DROP;
4536
4537         return NF_ACCEPT;
4538 }
4539
4540 static unsigned int selinux_ipv4_output(unsigned int hooknum,
4541                                         struct sk_buff *skb,
4542                                         const struct net_device *in,
4543                                         const struct net_device *out,
4544                                         int (*okfn)(struct sk_buff *))
4545 {
4546         return selinux_ip_output(skb, PF_INET);
4547 }
4548
4549 static unsigned int selinux_ip_postroute_compat(struct sk_buff *skb,
4550                                                 int ifindex,
4551                                                 u16 family)
4552 {
4553         struct sock *sk = skb->sk;
4554         struct sk_security_struct *sksec;
4555         struct common_audit_data ad;
4556         char *addrp;
4557         u8 proto;
4558
4559         if (sk == NULL)
4560                 return NF_ACCEPT;
4561         sksec = sk->sk_security;
4562
4563         COMMON_AUDIT_DATA_INIT(&ad, NET);
4564         ad.u.net.netif = ifindex;
4565         ad.u.net.family = family;
4566         if (selinux_parse_skb(skb, &ad, &addrp, 0, &proto))
4567                 return NF_DROP;
4568
4569         if (selinux_secmark_enabled())
4570                 if (avc_has_perm(sksec->sid, skb->secmark,
4571                                  SECCLASS_PACKET, PACKET__SEND, &ad))
4572                         return NF_DROP_ERR(-ECONNREFUSED);
4573
4574         if (selinux_xfrm_postroute_last(sksec->sid, skb, &ad, proto))
4575                 return NF_DROP_ERR(-ECONNREFUSED);
4576
4577         return NF_ACCEPT;
4578 }
4579
4580 static unsigned int selinux_ip_postroute(struct sk_buff *skb, int ifindex,
4581                                          u16 family)
4582 {
4583         u32 secmark_perm;
4584         u32 peer_sid;
4585         struct sock *sk;
4586         struct common_audit_data ad;
4587         char *addrp;
4588         u8 secmark_active;
4589         u8 peerlbl_active;
4590
4591         /* If any sort of compatibility mode is enabled then handoff processing
4592          * to the selinux_ip_postroute_compat() function to deal with the
4593          * special handling.  We do this in an attempt to keep this function
4594          * as fast and as clean as possible. */
4595         if (!selinux_policycap_netpeer)
4596                 return selinux_ip_postroute_compat(skb, ifindex, family);
4597 #ifdef CONFIG_XFRM
4598         /* If skb->dst->xfrm is non-NULL then the packet is undergoing an IPsec
4599          * packet transformation so allow the packet to pass without any checks
4600          * since we'll have another chance to perform access control checks
4601          * when the packet is on it's final way out.
4602          * NOTE: there appear to be some IPv6 multicast cases where skb->dst
4603          *       is NULL, in this case go ahead and apply access control. */
4604         if (skb_dst(skb) != NULL && skb_dst(skb)->xfrm != NULL)
4605                 return NF_ACCEPT;
4606 #endif
4607         secmark_active = selinux_secmark_enabled();
4608         peerlbl_active = netlbl_enabled() || selinux_xfrm_enabled();
4609         if (!secmark_active && !peerlbl_active)
4610                 return NF_ACCEPT;
4611
4612         /* if the packet is being forwarded then get the peer label from the
4613          * packet itself; otherwise check to see if it is from a local
4614          * application or the kernel, if from an application get the peer label
4615          * from the sending socket, otherwise use the kernel's sid */
4616         sk = skb->sk;
4617         if (sk == NULL) {
4618                 if (skb->skb_iif) {
4619                         secmark_perm = PACKET__FORWARD_OUT;
4620                         if (selinux_skb_peerlbl_sid(skb, family, &peer_sid))
4621                                 return NF_DROP;
4622                 } else {
4623                         secmark_perm = PACKET__SEND;
4624                         peer_sid = SECINITSID_KERNEL;
4625                 }
4626         } else {
4627                 struct sk_security_struct *sksec = sk->sk_security;
4628                 peer_sid = sksec->sid;
4629                 secmark_perm = PACKET__SEND;
4630         }
4631
4632         COMMON_AUDIT_DATA_INIT(&ad, NET);
4633         ad.u.net.netif = ifindex;
4634         ad.u.net.family = family;
4635         if (selinux_parse_skb(skb, &ad, &addrp, 0, NULL))
4636                 return NF_DROP;
4637
4638         if (secmark_active)
4639                 if (avc_has_perm(peer_sid, skb->secmark,
4640                                  SECCLASS_PACKET, secmark_perm, &ad))
4641                         return NF_DROP_ERR(-ECONNREFUSED);
4642
4643         if (peerlbl_active) {
4644                 u32 if_sid;
4645                 u32 node_sid;
4646
4647                 if (sel_netif_sid(ifindex, &if_sid))
4648                         return NF_DROP;
4649                 if (avc_has_perm(peer_sid, if_sid,
4650                                  SECCLASS_NETIF, NETIF__EGRESS, &ad))
4651                         return NF_DROP_ERR(-ECONNREFUSED);
4652
4653                 if (sel_netnode_sid(addrp, family, &node_sid))
4654                         return NF_DROP;
4655                 if (avc_has_perm(peer_sid, node_sid,
4656                                  SECCLASS_NODE, NODE__SENDTO, &ad))
4657                         return NF_DROP_ERR(-ECONNREFUSED);
4658         }
4659
4660         return NF_ACCEPT;
4661 }
4662
4663 static unsigned int selinux_ipv4_postroute(unsigned int hooknum,
4664                                            struct sk_buff *skb,
4665                                            const struct net_device *in,
4666                                            const struct net_device *out,
4667                                            int (*okfn)(struct sk_buff *))
4668 {
4669         return selinux_ip_postroute(skb, out->ifindex, PF_INET);
4670 }
4671
4672 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
4673 static unsigned int selinux_ipv6_postroute(unsigned int hooknum,
4674                                            struct sk_buff *skb,
4675                                            const struct net_device *in,
4676                                            const struct net_device *out,
4677                                            int (*okfn)(struct sk_buff *))
4678 {
4679         return selinux_ip_postroute(skb, out->ifindex, PF_INET6);
4680 }
4681 #endif  /* IPV6 */
4682
4683 #endif  /* CONFIG_NETFILTER */
4684
4685 static int selinux_netlink_send(struct sock *sk, struct sk_buff *skb)
4686 {
4687         int err;
4688
4689         err = cap_netlink_send(sk, skb);
4690         if (err)
4691                 return err;
4692
4693         return selinux_nlmsg_perm(sk, skb);
4694 }
4695
4696 static int selinux_netlink_recv(struct sk_buff *skb, int capability)
4697 {
4698         int err;
4699         struct common_audit_data ad;
4700
4701         err = cap_netlink_recv(skb, capability);
4702         if (err)
4703                 return err;
4704
4705         COMMON_AUDIT_DATA_INIT(&ad, CAP);
4706         ad.u.cap = capability;
4707
4708         return avc_has_perm(NETLINK_CB(skb).sid, NETLINK_CB(skb).sid,
4709                             SECCLASS_CAPABILITY, CAP_TO_MASK(capability), &ad);
4710 }
4711
4712 static int ipc_alloc_security(struct task_struct *task,
4713                               struct kern_ipc_perm *perm,
4714                               u16 sclass)
4715 {
4716         struct ipc_security_struct *isec;
4717         u32 sid;
4718
4719         isec = kzalloc(sizeof(struct ipc_security_struct), GFP_KERNEL);
4720         if (!isec)
4721                 return -ENOMEM;
4722
4723         sid = task_sid(task);
4724         isec->sclass = sclass;
4725         isec->sid = sid;
4726         perm->security = isec;
4727
4728         return 0;
4729 }
4730
4731 static void ipc_free_security(struct kern_ipc_perm *perm)
4732 {
4733         struct ipc_security_struct *isec = perm->security;
4734         perm->security = NULL;
4735         kfree(isec);
4736 }
4737
4738 static int msg_msg_alloc_security(struct msg_msg *msg)
4739 {
4740         struct msg_security_struct *msec;
4741
4742         msec = kzalloc(sizeof(struct msg_security_struct), GFP_KERNEL);
4743         if (!msec)
4744                 return -ENOMEM;
4745
4746         msec->sid = SECINITSID_UNLABELED;
4747         msg->security = msec;
4748
4749         return 0;
4750 }
4751
4752 static void msg_msg_free_security(struct msg_msg *msg)
4753 {
4754         struct msg_security_struct *msec = msg->security;
4755
4756         msg->security = NULL;
4757         kfree(msec);
4758 }
4759
4760 static int ipc_has_perm(struct kern_ipc_perm *ipc_perms,
4761                         u32 perms)
4762 {
4763         struct ipc_security_struct *isec;
4764         struct common_audit_data ad;
4765         u32 sid = current_sid();
4766
4767         isec = ipc_perms->security;
4768
4769         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4770         ad.u.ipc_id = ipc_perms->key;
4771
4772         return avc_has_perm(sid, isec->sid, isec->sclass, perms, &ad);
4773 }
4774
4775 static int selinux_msg_msg_alloc_security(struct msg_msg *msg)
4776 {
4777         return msg_msg_alloc_security(msg);
4778 }
4779
4780 static void selinux_msg_msg_free_security(struct msg_msg *msg)
4781 {
4782         msg_msg_free_security(msg);
4783 }
4784
4785 /* message queue security operations */
4786 static int selinux_msg_queue_alloc_security(struct msg_queue *msq)
4787 {
4788         struct ipc_security_struct *isec;
4789         struct common_audit_data ad;
4790         u32 sid = current_sid();
4791         int rc;
4792
4793         rc = ipc_alloc_security(current, &msq->q_perm, SECCLASS_MSGQ);
4794         if (rc)
4795                 return rc;
4796
4797         isec = msq->q_perm.security;
4798
4799         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4800         ad.u.ipc_id = msq->q_perm.key;
4801
4802         rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
4803                           MSGQ__CREATE, &ad);
4804         if (rc) {
4805                 ipc_free_security(&msq->q_perm);
4806                 return rc;
4807         }
4808         return 0;
4809 }
4810
4811 static void selinux_msg_queue_free_security(struct msg_queue *msq)
4812 {
4813         ipc_free_security(&msq->q_perm);
4814 }
4815
4816 static int selinux_msg_queue_associate(struct msg_queue *msq, int msqflg)
4817 {
4818         struct ipc_security_struct *isec;
4819         struct common_audit_data ad;
4820         u32 sid = current_sid();
4821
4822         isec = msq->q_perm.security;
4823
4824         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4825         ad.u.ipc_id = msq->q_perm.key;
4826
4827         return avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
4828                             MSGQ__ASSOCIATE, &ad);
4829 }
4830
4831 static int selinux_msg_queue_msgctl(struct msg_queue *msq, int cmd)
4832 {
4833         int err;
4834         int perms;
4835
4836         switch (cmd) {
4837         case IPC_INFO:
4838         case MSG_INFO:
4839                 /* No specific object, just general system-wide information. */
4840                 return task_has_system(current, SYSTEM__IPC_INFO);
4841         case IPC_STAT:
4842         case MSG_STAT:
4843                 perms = MSGQ__GETATTR | MSGQ__ASSOCIATE;
4844                 break;
4845         case IPC_SET:
4846                 perms = MSGQ__SETATTR;
4847                 break;
4848         case IPC_RMID:
4849                 perms = MSGQ__DESTROY;
4850                 break;
4851         default:
4852                 return 0;
4853         }
4854
4855         err = ipc_has_perm(&msq->q_perm, perms);
4856         return err;
4857 }
4858
4859 static int selinux_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg, int msqflg)
4860 {
4861         struct ipc_security_struct *isec;
4862         struct msg_security_struct *msec;
4863         struct common_audit_data ad;
4864         u32 sid = current_sid();
4865         int rc;
4866
4867         isec = msq->q_perm.security;
4868         msec = msg->security;
4869
4870         /*
4871          * First time through, need to assign label to the message
4872          */
4873         if (msec->sid == SECINITSID_UNLABELED) {
4874                 /*
4875                  * Compute new sid based on current process and
4876                  * message queue this message will be stored in
4877                  */
4878                 rc = security_transition_sid(sid, isec->sid, SECCLASS_MSG,
4879                                              NULL, &msec->sid);
4880                 if (rc)
4881                         return rc;
4882         }
4883
4884         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4885         ad.u.ipc_id = msq->q_perm.key;
4886
4887         /* Can this process write to the queue? */
4888         rc = avc_has_perm(sid, isec->sid, SECCLASS_MSGQ,
4889                           MSGQ__WRITE, &ad);
4890         if (!rc)
4891                 /* Can this process send the message */
4892                 rc = avc_has_perm(sid, msec->sid, SECCLASS_MSG,
4893                                   MSG__SEND, &ad);
4894         if (!rc)
4895                 /* Can the message be put in the queue? */
4896                 rc = avc_has_perm(msec->sid, isec->sid, SECCLASS_MSGQ,
4897                                   MSGQ__ENQUEUE, &ad);
4898
4899         return rc;
4900 }
4901
4902 static int selinux_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
4903                                     struct task_struct *target,
4904                                     long type, int mode)
4905 {
4906         struct ipc_security_struct *isec;
4907         struct msg_security_struct *msec;
4908         struct common_audit_data ad;
4909         u32 sid = task_sid(target);
4910         int rc;
4911
4912         isec = msq->q_perm.security;
4913         msec = msg->security;
4914
4915         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4916         ad.u.ipc_id = msq->q_perm.key;
4917
4918         rc = avc_has_perm(sid, isec->sid,
4919                           SECCLASS_MSGQ, MSGQ__READ, &ad);
4920         if (!rc)
4921                 rc = avc_has_perm(sid, msec->sid,
4922                                   SECCLASS_MSG, MSG__RECEIVE, &ad);
4923         return rc;
4924 }
4925
4926 /* Shared Memory security operations */
4927 static int selinux_shm_alloc_security(struct shmid_kernel *shp)
4928 {
4929         struct ipc_security_struct *isec;
4930         struct common_audit_data ad;
4931         u32 sid = current_sid();
4932         int rc;
4933
4934         rc = ipc_alloc_security(current, &shp->shm_perm, SECCLASS_SHM);
4935         if (rc)
4936                 return rc;
4937
4938         isec = shp->shm_perm.security;
4939
4940         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4941         ad.u.ipc_id = shp->shm_perm.key;
4942
4943         rc = avc_has_perm(sid, isec->sid, SECCLASS_SHM,
4944                           SHM__CREATE, &ad);
4945         if (rc) {
4946                 ipc_free_security(&shp->shm_perm);
4947                 return rc;
4948         }
4949         return 0;
4950 }
4951
4952 static void selinux_shm_free_security(struct shmid_kernel *shp)
4953 {
4954         ipc_free_security(&shp->shm_perm);
4955 }
4956
4957 static int selinux_shm_associate(struct shmid_kernel *shp, int shmflg)
4958 {
4959         struct ipc_security_struct *isec;
4960         struct common_audit_data ad;
4961         u32 sid = current_sid();
4962
4963         isec = shp->shm_perm.security;
4964
4965         COMMON_AUDIT_DATA_INIT(&ad, IPC);
4966         ad.u.ipc_id = shp->shm_perm.key;
4967
4968         return avc_has_perm(sid, isec->sid, SECCLASS_SHM,
4969                             SHM__ASSOCIATE, &ad);
4970 }
4971
4972 /* Note, at this point, shp is locked down */
4973 static int selinux_shm_shmctl(struct shmid_kernel *shp, int cmd)
4974 {
4975         int perms;
4976         int err;
4977
4978         switch (cmd) {
4979         case IPC_INFO:
4980         case SHM_INFO:
4981                 /* No specific object, just general system-wide information. */
4982                 return task_has_system(current, SYSTEM__IPC_INFO);
4983         case IPC_STAT:
4984         case SHM_STAT:
4985                 perms = SHM__GETATTR | SHM__ASSOCIATE;
4986                 break;
4987         case IPC_SET:
4988                 perms = SHM__SETATTR;
4989                 break;
4990         case SHM_LOCK:
4991         case SHM_UNLOCK:
4992                 perms = SHM__LOCK;
4993                 break;
4994         case IPC_RMID:
4995                 perms = SHM__DESTROY;
4996                 break;
4997         default:
4998                 return 0;
4999         }
5000
5001         err = ipc_has_perm(&shp->shm_perm, perms);
5002         return err;
5003 }
5004
5005 static int selinux_shm_shmat(struct shmid_kernel *shp,
5006                              char __user *shmaddr, int shmflg)
5007 {
5008         u32 perms;
5009
5010         if (shmflg & SHM_RDONLY)
5011                 perms = SHM__READ;
5012         else
5013                 perms = SHM__READ | SHM__WRITE;
5014
5015         return ipc_has_perm(&shp->shm_perm, perms);
5016 }
5017
5018 /* Semaphore security operations */
5019 static int selinux_sem_alloc_security(struct sem_array *sma)
5020 {
5021         struct ipc_security_struct *isec;
5022         struct common_audit_data ad;
5023         u32 sid = current_sid();
5024         int rc;
5025
5026         rc = ipc_alloc_security(current, &sma->sem_perm, SECCLASS_SEM);
5027         if (rc)
5028                 return rc;
5029
5030         isec = sma->sem_perm.security;
5031
5032         COMMON_AUDIT_DATA_INIT(&ad, IPC);
5033         ad.u.ipc_id = sma->sem_perm.key;
5034
5035         rc = avc_has_perm(sid, isec->sid, SECCLASS_SEM,
5036                           SEM__CREATE, &ad);
5037         if (rc) {
5038                 ipc_free_security(&sma->sem_perm);
5039                 return rc;
5040         }
5041         return 0;
5042 }
5043
5044 static void selinux_sem_free_security(struct sem_array *sma)
5045 {
5046         ipc_free_security(&sma->sem_perm);
5047 }
5048
5049 static int selinux_sem_associate(struct sem_array *sma, int semflg)
5050 {
5051         struct ipc_security_struct *isec;
5052         struct common_audit_data ad;
5053         u32 sid = current_sid();
5054
5055         isec = sma->sem_perm.security;
5056
5057         COMMON_AUDIT_DATA_INIT(&ad, IPC);
5058         ad.u.ipc_id = sma->sem_perm.key;
5059
5060         return avc_has_perm(sid, isec->sid, SECCLASS_SEM,
5061                             SEM__ASSOCIATE, &ad);
5062 }
5063
5064 /* Note, at this point, sma is locked down */
5065 static int selinux_sem_semctl(struct sem_array *sma, int cmd)
5066 {
5067         int err;
5068         u32 perms;
5069
5070         switch (cmd) {
5071         case IPC_INFO:
5072         case SEM_INFO:
5073                 /* No specific object, just general system-wide information. */
5074                 return task_has_system(current, SYSTEM__IPC_INFO);
5075         case GETPID:
5076         case GETNCNT:
5077         case GETZCNT:
5078                 perms = SEM__GETATTR;
5079                 break;
5080         case GETVAL:
5081         case GETALL:
5082                 perms = SEM__READ;
5083                 break;
5084         case SETVAL:
5085         case SETALL:
5086                 perms = SEM__WRITE;
5087                 break;
5088         case IPC_RMID:
5089                 perms = SEM__DESTROY;
5090                 break;
5091         case IPC_SET:
5092                 perms = SEM__SETATTR;
5093                 break;
5094         case IPC_STAT:
5095         case SEM_STAT:
5096                 perms = SEM__GETATTR | SEM__ASSOCIATE;
5097                 break;
5098         default:
5099                 return 0;
5100         }
5101
5102         err = ipc_has_perm(&sma->sem_perm, perms);
5103         return err;
5104 }
5105
5106 static int selinux_sem_semop(struct sem_array *sma,
5107                              struct sembuf *sops, unsigned nsops, int alter)
5108 {
5109         u32 perms;
5110
5111         if (alter)
5112                 perms = SEM__READ | SEM__WRITE;
5113         else
5114                 perms = SEM__READ;
5115
5116         return ipc_has_perm(&sma->sem_perm, perms);
5117 }
5118
5119 static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag)
5120 {
5121         u32 av = 0;
5122
5123         av = 0;
5124         if (flag & S_IRUGO)
5125                 av |= IPC__UNIX_READ;
5126         if (flag & S_IWUGO)
5127                 av |= IPC__UNIX_WRITE;
5128
5129         if (av == 0)
5130                 return 0;
5131
5132         return ipc_has_perm(ipcp, av);
5133 }
5134
5135 static void selinux_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid)
5136 {
5137         struct ipc_security_struct *isec = ipcp->security;
5138         *secid = isec->sid;
5139 }
5140
5141 static void selinux_d_instantiate(struct dentry *dentry, struct inode *inode)
5142 {
5143         if (inode)
5144                 inode_doinit_with_dentry(inode, dentry);
5145 }
5146
5147 static int selinux_getprocattr(struct task_struct *p,
5148                                char *name, char **value)
5149 {
5150         const struct task_security_struct *__tsec;
5151         u32 sid;
5152         int error;
5153         unsigned len;
5154
5155         if (current != p) {
5156                 error = current_has_perm(p, PROCESS__GETATTR);
5157                 if (error)
5158                         return error;
5159         }
5160
5161         rcu_read_lock();
5162         __tsec = __task_cred(p)->security;
5163
5164         if (!strcmp(name, "current"))
5165                 sid = __tsec->sid;
5166         else if (!strcmp(name, "prev"))
5167                 sid = __tsec->osid;
5168         else if (!strcmp(name, "exec"))
5169                 sid = __tsec->exec_sid;
5170         else if (!strcmp(name, "fscreate"))
5171                 sid = __tsec->create_sid;
5172         else if (!strcmp(name, "keycreate"))
5173                 sid = __tsec->keycreate_sid;
5174         else if (!strcmp(name, "sockcreate"))
5175                 sid = __tsec->sockcreate_sid;
5176         else
5177                 goto invalid;
5178         rcu_read_unlock();
5179
5180         if (!sid)
5181                 return 0;
5182
5183         error = security_sid_to_context(sid, value, &len);
5184         if (error)
5185                 return error;
5186         return len;
5187
5188 invalid:
5189         rcu_read_unlock();
5190         return -EINVAL;
5191 }
5192
5193 static int selinux_setprocattr(struct task_struct *p,
5194                                char *name, void *value, size_t size)
5195 {
5196         struct task_security_struct *tsec;
5197         struct task_struct *tracer;
5198         struct cred *new;
5199         u32 sid = 0, ptsid;
5200         int error;
5201         char *str = value;
5202
5203         if (current != p) {
5204                 /* SELinux only allows a process to change its own
5205                    security attributes. */
5206                 return -EACCES;
5207         }
5208
5209         /*
5210          * Basic control over ability to set these attributes at all.
5211          * current == p, but we'll pass them separately in case the
5212          * above restriction is ever removed.
5213          */
5214         if (!strcmp(name, "exec"))
5215                 error = current_has_perm(p, PROCESS__SETEXEC);
5216         else if (!strcmp(name, "fscreate"))
5217                 error = current_has_perm(p, PROCESS__SETFSCREATE);
5218         else if (!strcmp(name, "keycreate"))
5219                 error = current_has_perm(p, PROCESS__SETKEYCREATE);
5220         else if (!strcmp(name, "sockcreate"))
5221                 error = current_has_perm(p, PROCESS__SETSOCKCREATE);
5222         else if (!strcmp(name, "current"))
5223                 error = current_has_perm(p, PROCESS__SETCURRENT);
5224         else
5225                 error = -EINVAL;
5226         if (error)
5227                 return error;
5228
5229         /* Obtain a SID for the context, if one was specified. */
5230         if (size && str[1] && str[1] != '\n') {
5231                 if (str[size-1] == '\n') {
5232                         str[size-1] = 0;
5233                         size--;
5234                 }
5235                 error = security_context_to_sid(value, size, &sid);
5236                 if (error == -EINVAL && !strcmp(name, "fscreate")) {
5237                         if (!capable(CAP_MAC_ADMIN))
5238                                 return error;
5239                         error = security_context_to_sid_force(value, size,
5240                                                               &sid);
5241                 }
5242                 if (error)
5243                         return error;
5244         }
5245
5246         new = prepare_creds();
5247         if (!new)
5248                 return -ENOMEM;
5249
5250         /* Permission checking based on the specified context is
5251            performed during the actual operation (execve,
5252            open/mkdir/...), when we know the full context of the
5253            operation.  See selinux_bprm_set_creds for the execve
5254            checks and may_create for the file creation checks. The
5255            operation will then fail if the context is not permitted. */
5256         tsec = new->security;
5257         if (!strcmp(name, "exec")) {
5258                 tsec->exec_sid = sid;
5259         } else if (!strcmp(name, "fscreate")) {
5260                 tsec->create_sid = sid;
5261         } else if (!strcmp(name, "keycreate")) {
5262                 error = may_create_key(sid, p);
5263                 if (error)
5264                         goto abort_change;
5265                 tsec->keycreate_sid = sid;
5266         } else if (!strcmp(name, "sockcreate")) {
5267                 tsec->sockcreate_sid = sid;
5268         } else if (!strcmp(name, "current")) {
5269                 error = -EINVAL;
5270                 if (sid == 0)
5271                         goto abort_change;
5272
5273                 /* Only allow single threaded processes to change context */
5274                 error = -EPERM;
5275                 if (!current_is_single_threaded()) {
5276                         error = security_bounded_transition(tsec->sid, sid);
5277                         if (error)
5278                                 goto abort_change;
5279                 }
5280
5281                 /* Check permissions for the transition. */
5282                 error = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
5283                                      PROCESS__DYNTRANSITION, NULL);
5284                 if (error)
5285                         goto abort_change;
5286
5287                 /* Check for ptracing, and update the task SID if ok.
5288                    Otherwise, leave SID unchanged and fail. */
5289                 ptsid = 0;
5290                 task_lock(p);
5291                 tracer = tracehook_tracer_task(p);
5292                 if (tracer)
5293                         ptsid = task_sid(tracer);
5294                 task_unlock(p);
5295
5296                 if (tracer) {
5297                         error = avc_has_perm(ptsid, sid, SECCLASS_PROCESS,
5298                                              PROCESS__PTRACE, NULL);
5299                         if (error)
5300                                 goto abort_change;
5301                 }
5302
5303                 tsec->sid = sid;
5304         } else {
5305                 error = -EINVAL;
5306                 goto abort_change;
5307         }
5308
5309         commit_creds(new);
5310         return size;
5311
5312 abort_change:
5313         abort_creds(new);
5314         return error;
5315 }
5316
5317 static int selinux_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
5318 {
5319         return security_sid_to_context(secid, secdata, seclen);
5320 }
5321
5322 static int selinux_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
5323 {
5324         return security_context_to_sid(secdata, seclen, secid);
5325 }
5326
5327 static void selinux_release_secctx(char *secdata, u32 seclen)
5328 {
5329         kfree(secdata);
5330 }
5331
5332 /*
5333  *      called with inode->i_mutex locked
5334  */
5335 static int selinux_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
5336 {
5337         return selinux_inode_setsecurity(inode, XATTR_SELINUX_SUFFIX, ctx, ctxlen, 0);
5338 }
5339
5340 /*
5341  *      called with inode->i_mutex locked
5342  */
5343 static int selinux_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
5344 {
5345         return __vfs_setxattr_noperm(dentry, XATTR_NAME_SELINUX, ctx, ctxlen, 0);
5346 }
5347
5348 static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
5349 {
5350         int len = 0;
5351         len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX,
5352                                                 ctx, true);
5353         if (len < 0)
5354                 return len;
5355         *ctxlen = len;
5356         return 0;
5357 }
5358 #ifdef CONFIG_KEYS
5359
5360 static int selinux_key_alloc(struct key *k, const struct cred *cred,
5361                              unsigned long flags)
5362 {
5363         const struct task_security_struct *tsec;
5364         struct key_security_struct *ksec;
5365
5366         ksec = kzalloc(sizeof(struct key_security_struct), GFP_KERNEL);
5367         if (!ksec)
5368                 return -ENOMEM;
5369
5370         tsec = cred->security;
5371         if (tsec->keycreate_sid)
5372                 ksec->sid = tsec->keycreate_sid;
5373         else
5374                 ksec->sid = tsec->sid;
5375
5376         k->security = ksec;
5377         return 0;
5378 }
5379
5380 static void selinux_key_free(struct key *k)
5381 {
5382         struct key_security_struct *ksec = k->security;
5383
5384         k->security = NULL;
5385         kfree(ksec);
5386 }
5387
5388 static int selinux_key_permission(key_ref_t key_ref,
5389                                   const struct cred *cred,
5390                                   key_perm_t perm)
5391 {
5392         struct key *key;
5393         struct key_security_struct *ksec;
5394         u32 sid;
5395
5396         /* if no specific permissions are requested, we skip the
5397            permission check. No serious, additional covert channels
5398            appear to be created. */
5399         if (perm == 0)
5400                 return 0;
5401
5402         sid = cred_sid(cred);
5403
5404         key = key_ref_to_ptr(key_ref);
5405         ksec = key->security;
5406
5407         return avc_has_perm(sid, ksec->sid, SECCLASS_KEY, perm, NULL);
5408 }
5409
5410 static int selinux_key_getsecurity(struct key *key, char **_buffer)
5411 {
5412         struct key_security_struct *ksec = key->security;
5413         char *context = NULL;
5414         unsigned len;
5415         int rc;
5416
5417         rc = security_sid_to_context(ksec->sid, &context, &len);
5418         if (!rc)
5419                 rc = len;
5420         *_buffer = context;
5421         return rc;
5422 }
5423
5424 #endif
5425
5426 static struct security_operations selinux_ops = {
5427         .name =                         "selinux",
5428
5429         .ptrace_access_check =          selinux_ptrace_access_check,
5430         .ptrace_traceme =               selinux_ptrace_traceme,
5431         .capget =                       selinux_capget,
5432         .capset =                       selinux_capset,
5433         .capable =                      selinux_capable,
5434         .quotactl =                     selinux_quotactl,
5435         .quota_on =                     selinux_quota_on,
5436         .syslog =                       selinux_syslog,
5437         .vm_enough_memory =             selinux_vm_enough_memory,
5438
5439         .netlink_send =                 selinux_netlink_send,
5440         .netlink_recv =                 selinux_netlink_recv,
5441
5442         .bprm_set_creds =               selinux_bprm_set_creds,
5443         .bprm_committing_creds =        selinux_bprm_committing_creds,
5444         .bprm_committed_creds =         selinux_bprm_committed_creds,
5445         .bprm_secureexec =              selinux_bprm_secureexec,
5446
5447         .sb_alloc_security =            selinux_sb_alloc_security,
5448         .sb_free_security =             selinux_sb_free_security,
5449         .sb_copy_data =                 selinux_sb_copy_data,
5450         .sb_remount =                   selinux_sb_remount,
5451         .sb_kern_mount =                selinux_sb_kern_mount,
5452         .sb_show_options =              selinux_sb_show_options,
5453         .sb_statfs =                    selinux_sb_statfs,
5454         .sb_mount =                     selinux_mount,
5455         .sb_umount =                    selinux_umount,
5456         .sb_set_mnt_opts =              selinux_set_mnt_opts,
5457         .sb_clone_mnt_opts =            selinux_sb_clone_mnt_opts,
5458         .sb_parse_opts_str =            selinux_parse_opts_str,
5459
5460
5461         .inode_alloc_security =         selinux_inode_alloc_security,
5462         .inode_free_security =          selinux_inode_free_security,
5463         .inode_init_security =          selinux_inode_init_security,
5464         .inode_create =                 selinux_inode_create,
5465         .inode_link =                   selinux_inode_link,
5466         .inode_unlink =                 selinux_inode_unlink,
5467         .inode_symlink =                selinux_inode_symlink,
5468         .inode_mkdir =                  selinux_inode_mkdir,
5469         .inode_rmdir =                  selinux_inode_rmdir,
5470         .inode_mknod =                  selinux_inode_mknod,
5471         .inode_rename =                 selinux_inode_rename,
5472         .inode_readlink =               selinux_inode_readlink,
5473         .inode_follow_link =            selinux_inode_follow_link,
5474         .inode_permission =             selinux_inode_permission,
5475         .inode_setattr =                selinux_inode_setattr,
5476         .inode_getattr =                selinux_inode_getattr,
5477         .inode_setxattr =               selinux_inode_setxattr,
5478         .inode_post_setxattr =          selinux_inode_post_setxattr,
5479         .inode_getxattr =               selinux_inode_getxattr,
5480         .inode_listxattr =              selinux_inode_listxattr,
5481         .inode_removexattr =            selinux_inode_removexattr,
5482         .inode_getsecurity =            selinux_inode_getsecurity,
5483         .inode_setsecurity =            selinux_inode_setsecurity,
5484         .inode_listsecurity =           selinux_inode_listsecurity,
5485         .inode_getsecid =               selinux_inode_getsecid,
5486
5487         .file_permission =              selinux_file_permission,
5488         .file_alloc_security =          selinux_file_alloc_security,
5489         .file_free_security =           selinux_file_free_security,
5490         .file_ioctl =                   selinux_file_ioctl,
5491         .file_mmap =                    selinux_file_mmap,
5492         .file_mprotect =                selinux_file_mprotect,
5493         .file_lock =                    selinux_file_lock,
5494         .file_fcntl =                   selinux_file_fcntl,
5495         .file_set_fowner =              selinux_file_set_fowner,
5496         .file_send_sigiotask =          selinux_file_send_sigiotask,
5497         .file_receive =                 selinux_file_receive,
5498
5499         .dentry_open =                  selinux_dentry_open,
5500
5501         .task_create =                  selinux_task_create,
5502         .cred_alloc_blank =             selinux_cred_alloc_blank,
5503         .cred_free =                    selinux_cred_free,
5504         .cred_prepare =                 selinux_cred_prepare,
5505         .cred_transfer =                selinux_cred_transfer,
5506         .kernel_act_as =                selinux_kernel_act_as,
5507         .kernel_create_files_as =       selinux_kernel_create_files_as,
5508         .kernel_module_request =        selinux_kernel_module_request,
5509         .task_setpgid =                 selinux_task_setpgid,
5510         .task_getpgid =                 selinux_task_getpgid,
5511         .task_getsid =                  selinux_task_getsid,
5512         .task_getsecid =                selinux_task_getsecid,
5513         .task_setnice =                 selinux_task_setnice,
5514         .task_setioprio =               selinux_task_setioprio,
5515         .task_getioprio =               selinux_task_getioprio,
5516         .task_setrlimit =               selinux_task_setrlimit,
5517         .task_setscheduler =            selinux_task_setscheduler,
5518         .task_getscheduler =            selinux_task_getscheduler,
5519         .task_movememory =              selinux_task_movememory,
5520         .task_kill =                    selinux_task_kill,
5521         .task_wait =                    selinux_task_wait,
5522         .task_to_inode =                selinux_task_to_inode,
5523
5524         .ipc_permission =               selinux_ipc_permission,
5525         .ipc_getsecid =                 selinux_ipc_getsecid,
5526
5527         .msg_msg_alloc_security =       selinux_msg_msg_alloc_security,
5528         .msg_msg_free_security =        selinux_msg_msg_free_security,
5529
5530         .msg_queue_alloc_security =     selinux_msg_queue_alloc_security,
5531         .msg_queue_free_security =      selinux_msg_queue_free_security,
5532         .msg_queue_associate =          selinux_msg_queue_associate,
5533         .msg_queue_msgctl =             selinux_msg_queue_msgctl,
5534         .msg_queue_msgsnd =             selinux_msg_queue_msgsnd,
5535         .msg_queue_msgrcv =             selinux_msg_queue_msgrcv,
5536
5537         .shm_alloc_security =           selinux_shm_alloc_security,
5538         .shm_free_security =            selinux_shm_free_security,
5539         .shm_associate =                selinux_shm_associate,
5540         .shm_shmctl =                   selinux_shm_shmctl,
5541         .shm_shmat =                    selinux_shm_shmat,
5542
5543         .sem_alloc_security =           selinux_sem_alloc_security,
5544         .sem_free_security =            selinux_sem_free_security,
5545         .sem_associate =                selinux_sem_associate,
5546         .sem_semctl =                   selinux_sem_semctl,
5547         .sem_semop =                    selinux_sem_semop,
5548
5549         .d_instantiate =                selinux_d_instantiate,
5550
5551         .getprocattr =                  selinux_getprocattr,
5552         .setprocattr =                  selinux_setprocattr,
5553
5554         .secid_to_secctx =              selinux_secid_to_secctx,
5555         .secctx_to_secid =              selinux_secctx_to_secid,
5556         .release_secctx =               selinux_release_secctx,
5557         .inode_notifysecctx =           selinux_inode_notifysecctx,
5558         .inode_setsecctx =              selinux_inode_setsecctx,
5559         .inode_getsecctx =              selinux_inode_getsecctx,
5560
5561         .unix_stream_connect =          selinux_socket_unix_stream_connect,
5562         .unix_may_send =                selinux_socket_unix_may_send,
5563
5564         .socket_create =                selinux_socket_create,
5565         .socket_post_create =           selinux_socket_post_create,
5566         .socket_bind =                  selinux_socket_bind,
5567         .socket_connect =               selinux_socket_connect,
5568         .socket_listen =                selinux_socket_listen,
5569         .socket_accept =                selinux_socket_accept,
5570         .socket_sendmsg =               selinux_socket_sendmsg,
5571         .socket_recvmsg =               selinux_socket_recvmsg,
5572         .socket_getsockname =           selinux_socket_getsockname,
5573         .socket_getpeername =           selinux_socket_getpeername,
5574         .socket_getsockopt =            selinux_socket_getsockopt,
5575         .socket_setsockopt =            selinux_socket_setsockopt,
5576         .socket_shutdown =              selinux_socket_shutdown,
5577         .socket_sock_rcv_skb =          selinux_socket_sock_rcv_skb,
5578         .socket_getpeersec_stream =     selinux_socket_getpeersec_stream,
5579         .socket_getpeersec_dgram =      selinux_socket_getpeersec_dgram,
5580         .sk_alloc_security =            selinux_sk_alloc_security,
5581         .sk_free_security =             selinux_sk_free_security,
5582         .sk_clone_security =            selinux_sk_clone_security,
5583         .sk_getsecid =                  selinux_sk_getsecid,
5584         .sock_graft =                   selinux_sock_graft,
5585         .inet_conn_request =            selinux_inet_conn_request,
5586         .inet_csk_clone =               selinux_inet_csk_clone,
5587         .inet_conn_established =        selinux_inet_conn_established,
5588         .secmark_relabel_packet =       selinux_secmark_relabel_packet,
5589         .secmark_refcount_inc =         selinux_secmark_refcount_inc,
5590         .secmark_refcount_dec =         selinux_secmark_refcount_dec,
5591         .req_classify_flow =            selinux_req_classify_flow,
5592         .tun_dev_create =               selinux_tun_dev_create,
5593         .tun_dev_post_create =          selinux_tun_dev_post_create,
5594         .tun_dev_attach =               selinux_tun_dev_attach,
5595
5596 #ifdef CONFIG_SECURITY_NETWORK_XFRM
5597         .xfrm_policy_alloc_security =   selinux_xfrm_policy_alloc,
5598         .xfrm_policy_clone_security =   selinux_xfrm_policy_clone,
5599         .xfrm_policy_free_security =    selinux_xfrm_policy_free,
5600         .xfrm_policy_delete_security =  selinux_xfrm_policy_delete,
5601         .xfrm_state_alloc_security =    selinux_xfrm_state_alloc,
5602         .xfrm_state_free_security =     selinux_xfrm_state_free,
5603         .xfrm_state_delete_security =   selinux_xfrm_state_delete,
5604         .xfrm_policy_lookup =           selinux_xfrm_policy_lookup,
5605         .xfrm_state_pol_flow_match =    selinux_xfrm_state_pol_flow_match,
5606         .xfrm_decode_session =          selinux_xfrm_decode_session,
5607 #endif
5608
5609 #ifdef CONFIG_KEYS
5610         .key_alloc =                    selinux_key_alloc,
5611         .key_free =                     selinux_key_free,
5612         .key_permission =               selinux_key_permission,
5613         .key_getsecurity =              selinux_key_getsecurity,
5614 #endif
5615
5616 #ifdef CONFIG_AUDIT
5617         .audit_rule_init =              selinux_audit_rule_init,
5618         .audit_rule_known =             selinux_audit_rule_known,
5619         .audit_rule_match =             selinux_audit_rule_match,
5620         .audit_rule_free =              selinux_audit_rule_free,
5621 #endif
5622 };
5623
5624 static __init int selinux_init(void)
5625 {
5626         if (!security_module_enable(&selinux_ops)) {
5627                 selinux_enabled = 0;
5628                 return 0;
5629         }
5630
5631         if (!selinux_enabled) {
5632                 printk(KERN_INFO "SELinux:  Disabled at boot.\n");
5633                 return 0;
5634         }
5635
5636         printk(KERN_INFO "SELinux:  Initializing.\n");
5637
5638         /* Set the security state for the initial task. */
5639         cred_init_security();
5640
5641         default_noexec = !(VM_DATA_DEFAULT_FLAGS & VM_EXEC);
5642
5643         sel_inode_cache = kmem_cache_create("selinux_inode_security",
5644                                             sizeof(struct inode_security_struct),
5645                                             0, SLAB_PANIC, NULL);
5646         avc_init();
5647
5648         if (register_security(&selinux_ops))
5649                 panic("SELinux: Unable to register with kernel.\n");
5650
5651         if (selinux_enforcing)
5652                 printk(KERN_DEBUG "SELinux:  Starting in enforcing mode\n");
5653         else
5654                 printk(KERN_DEBUG "SELinux:  Starting in permissive mode\n");
5655
5656         return 0;
5657 }
5658
5659 static void delayed_superblock_init(struct super_block *sb, void *unused)
5660 {
5661         superblock_doinit(sb, NULL);
5662 }
5663
5664 void selinux_complete_init(void)
5665 {
5666         printk(KERN_DEBUG "SELinux:  Completing initialization.\n");
5667
5668         /* Set up any superblocks initialized prior to the policy load. */
5669         printk(KERN_DEBUG "SELinux:  Setting up existing superblocks.\n");
5670         iterate_supers(delayed_superblock_init, NULL);
5671 }
5672
5673 /* SELinux requires early initialization in order to label
5674    all processes and objects when they are created. */
5675 security_initcall(selinux_init);
5676
5677 #if defined(CONFIG_NETFILTER)
5678
5679 static struct nf_hook_ops selinux_ipv4_ops[] = {
5680         {
5681                 .hook =         selinux_ipv4_postroute,
5682                 .owner =        THIS_MODULE,
5683                 .pf =           PF_INET,
5684                 .hooknum =      NF_INET_POST_ROUTING,
5685                 .priority =     NF_IP_PRI_SELINUX_LAST,
5686         },
5687         {
5688                 .hook =         selinux_ipv4_forward,
5689                 .owner =        THIS_MODULE,
5690                 .pf =           PF_INET,
5691                 .hooknum =      NF_INET_FORWARD,
5692                 .priority =     NF_IP_PRI_SELINUX_FIRST,
5693         },
5694         {
5695                 .hook =         selinux_ipv4_output,
5696                 .owner =        THIS_MODULE,
5697                 .pf =           PF_INET,
5698                 .hooknum =      NF_INET_LOCAL_OUT,
5699                 .priority =     NF_IP_PRI_SELINUX_FIRST,
5700         }
5701 };
5702
5703 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5704
5705 static struct nf_hook_ops selinux_ipv6_ops[] = {
5706         {
5707                 .hook =         selinux_ipv6_postroute,
5708                 .owner =        THIS_MODULE,
5709                 .pf =           PF_INET6,
5710                 .hooknum =      NF_INET_POST_ROUTING,
5711                 .priority =     NF_IP6_PRI_SELINUX_LAST,
5712         },
5713         {
5714                 .hook =         selinux_ipv6_forward,
5715                 .owner =        THIS_MODULE,
5716                 .pf =           PF_INET6,
5717                 .hooknum =      NF_INET_FORWARD,
5718                 .priority =     NF_IP6_PRI_SELINUX_FIRST,
5719         }
5720 };
5721
5722 #endif  /* IPV6 */
5723
5724 static int __init selinux_nf_ip_init(void)
5725 {
5726         int err = 0;
5727
5728         if (!selinux_enabled)
5729                 goto out;
5730
5731         printk(KERN_DEBUG "SELinux:  Registering netfilter hooks\n");
5732
5733         err = nf_register_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5734         if (err)
5735                 panic("SELinux: nf_register_hooks for IPv4: error %d\n", err);
5736
5737 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5738         err = nf_register_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5739         if (err)
5740                 panic("SELinux: nf_register_hooks for IPv6: error %d\n", err);
5741 #endif  /* IPV6 */
5742
5743 out:
5744         return err;
5745 }
5746
5747 __initcall(selinux_nf_ip_init);
5748
5749 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
5750 static void selinux_nf_ip_exit(void)
5751 {
5752         printk(KERN_DEBUG "SELinux:  Unregistering netfilter hooks\n");
5753
5754         nf_unregister_hooks(selinux_ipv4_ops, ARRAY_SIZE(selinux_ipv4_ops));
5755 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
5756         nf_unregister_hooks(selinux_ipv6_ops, ARRAY_SIZE(selinux_ipv6_ops));
5757 #endif  /* IPV6 */
5758 }
5759 #endif
5760
5761 #else /* CONFIG_NETFILTER */
5762
5763 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
5764 #define selinux_nf_ip_exit()
5765 #endif
5766
5767 #endif /* CONFIG_NETFILTER */
5768
5769 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
5770 static int selinux_disabled;
5771
5772 int selinux_disable(void)
5773 {
5774         extern void exit_sel_fs(void);
5775
5776         if (ss_initialized) {
5777                 /* Not permitted after initial policy load. */
5778                 return -EINVAL;
5779         }
5780
5781         if (selinux_disabled) {
5782                 /* Only do this once. */
5783                 return -EINVAL;
5784         }
5785
5786         printk(KERN_INFO "SELinux:  Disabled at runtime.\n");
5787
5788         selinux_disabled = 1;
5789         selinux_enabled = 0;
5790
5791         reset_security_ops();
5792
5793         /* Try to destroy the avc node cache */
5794         avc_disable();
5795
5796         /* Unregister netfilter hooks. */
5797         selinux_nf_ip_exit();
5798
5799         /* Unregister selinuxfs. */
5800         exit_sel_fs();
5801
5802         return 0;
5803 }
5804 #endif