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