Smack: Clean up comments
[linux-2.6.git] / security / smack / smack_lsm.c
1 /*
2  *  Simplified MAC Kernel (smack) security module
3  *
4  *  This file contains the smack hook function implementations.
5  *
6  *  Authors:
7  *      Casey Schaufler <casey@schaufler-ca.com>
8  *      Jarkko Sakkinen <ext-jarkko.2.sakkinen@nokia.com>
9  *
10  *  Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
11  *  Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
12  *                Paul Moore <paul@paul-moore.com>
13  *  Copyright (C) 2010 Nokia Corporation
14  *
15  *      This program is free software; you can redistribute it and/or modify
16  *      it under the terms of the GNU General Public License version 2,
17  *      as published by the Free Software Foundation.
18  */
19
20 #include <linux/xattr.h>
21 #include <linux/pagemap.h>
22 #include <linux/mount.h>
23 #include <linux/stat.h>
24 #include <linux/kd.h>
25 #include <asm/ioctls.h>
26 #include <linux/ip.h>
27 #include <linux/tcp.h>
28 #include <linux/udp.h>
29 #include <linux/slab.h>
30 #include <linux/mutex.h>
31 #include <linux/pipe_fs_i.h>
32 #include <net/netlabel.h>
33 #include <net/cipso_ipv4.h>
34 #include <linux/audit.h>
35 #include <linux/magic.h>
36 #include <linux/dcache.h>
37 #include "smack.h"
38
39 #define task_security(task)     (task_cred_xxx((task), security))
40
41 #define TRANS_TRUE      "TRUE"
42 #define TRANS_TRUE_SIZE 4
43
44 /**
45  * smk_fetch - Fetch the smack label from a file.
46  * @ip: a pointer to the inode
47  * @dp: a pointer to the dentry
48  *
49  * Returns a pointer to the master list entry for the Smack label
50  * or NULL if there was no label to fetch.
51  */
52 static char *smk_fetch(const char *name, struct inode *ip, struct dentry *dp)
53 {
54         int rc;
55         char in[SMK_LABELLEN];
56
57         if (ip->i_op->getxattr == NULL)
58                 return NULL;
59
60         rc = ip->i_op->getxattr(dp, name, in, SMK_LABELLEN);
61         if (rc < 0)
62                 return NULL;
63
64         return smk_import(in, rc);
65 }
66
67 /**
68  * new_inode_smack - allocate an inode security blob
69  * @smack: a pointer to the Smack label to use in the blob
70  *
71  * Returns the new blob or NULL if there's no memory available
72  */
73 struct inode_smack *new_inode_smack(char *smack)
74 {
75         struct inode_smack *isp;
76
77         isp = kzalloc(sizeof(struct inode_smack), GFP_KERNEL);
78         if (isp == NULL)
79                 return NULL;
80
81         isp->smk_inode = smack;
82         isp->smk_flags = 0;
83         mutex_init(&isp->smk_lock);
84
85         return isp;
86 }
87
88 /**
89  * new_task_smack - allocate a task security blob
90  * @smack: a pointer to the Smack label to use in the blob
91  *
92  * Returns the new blob or NULL if there's no memory available
93  */
94 static struct task_smack *new_task_smack(char *task, char *forked, gfp_t gfp)
95 {
96         struct task_smack *tsp;
97
98         tsp = kzalloc(sizeof(struct task_smack), gfp);
99         if (tsp == NULL)
100                 return NULL;
101
102         tsp->smk_task = task;
103         tsp->smk_forked = forked;
104         INIT_LIST_HEAD(&tsp->smk_rules);
105         mutex_init(&tsp->smk_rules_lock);
106
107         return tsp;
108 }
109
110 /**
111  * smk_copy_rules - copy a rule set
112  * @nhead - new rules header pointer
113  * @ohead - old rules header pointer
114  *
115  * Returns 0 on success, -ENOMEM on error
116  */
117 static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead,
118                                 gfp_t gfp)
119 {
120         struct smack_rule *nrp;
121         struct smack_rule *orp;
122         int rc = 0;
123
124         INIT_LIST_HEAD(nhead);
125
126         list_for_each_entry_rcu(orp, ohead, list) {
127                 nrp = kzalloc(sizeof(struct smack_rule), gfp);
128                 if (nrp == NULL) {
129                         rc = -ENOMEM;
130                         break;
131                 }
132                 *nrp = *orp;
133                 list_add_rcu(&nrp->list, nhead);
134         }
135         return rc;
136 }
137
138 /*
139  * LSM hooks.
140  * We he, that is fun!
141  */
142
143 /**
144  * smack_ptrace_access_check - Smack approval on PTRACE_ATTACH
145  * @ctp: child task pointer
146  * @mode: ptrace attachment mode
147  *
148  * Returns 0 if access is OK, an error code otherwise
149  *
150  * Do the capability checks, and require read and write.
151  */
152 static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode)
153 {
154         int rc;
155         struct smk_audit_info ad;
156         char *tsp;
157
158         rc = cap_ptrace_access_check(ctp, mode);
159         if (rc != 0)
160                 return rc;
161
162         tsp = smk_of_task(task_security(ctp));
163         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
164         smk_ad_setfield_u_tsk(&ad, ctp);
165
166         rc = smk_curacc(tsp, MAY_READWRITE, &ad);
167         return rc;
168 }
169
170 /**
171  * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME
172  * @ptp: parent task pointer
173  *
174  * Returns 0 if access is OK, an error code otherwise
175  *
176  * Do the capability checks, and require read and write.
177  */
178 static int smack_ptrace_traceme(struct task_struct *ptp)
179 {
180         int rc;
181         struct smk_audit_info ad;
182         char *tsp;
183
184         rc = cap_ptrace_traceme(ptp);
185         if (rc != 0)
186                 return rc;
187
188         tsp = smk_of_task(task_security(ptp));
189         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
190         smk_ad_setfield_u_tsk(&ad, ptp);
191
192         rc = smk_curacc(tsp, MAY_READWRITE, &ad);
193         return rc;
194 }
195
196 /**
197  * smack_syslog - Smack approval on syslog
198  * @type: message type
199  *
200  * Require that the task has the floor label
201  *
202  * Returns 0 on success, error code otherwise.
203  */
204 static int smack_syslog(int typefrom_file)
205 {
206         int rc = 0;
207         char *sp = smk_of_current();
208
209         if (capable(CAP_MAC_OVERRIDE))
210                 return 0;
211
212          if (sp != smack_known_floor.smk_known)
213                 rc = -EACCES;
214
215         return rc;
216 }
217
218
219 /*
220  * Superblock Hooks.
221  */
222
223 /**
224  * smack_sb_alloc_security - allocate a superblock blob
225  * @sb: the superblock getting the blob
226  *
227  * Returns 0 on success or -ENOMEM on error.
228  */
229 static int smack_sb_alloc_security(struct super_block *sb)
230 {
231         struct superblock_smack *sbsp;
232
233         sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
234
235         if (sbsp == NULL)
236                 return -ENOMEM;
237
238         sbsp->smk_root = smack_known_floor.smk_known;
239         sbsp->smk_default = smack_known_floor.smk_known;
240         sbsp->smk_floor = smack_known_floor.smk_known;
241         sbsp->smk_hat = smack_known_hat.smk_known;
242         sbsp->smk_initialized = 0;
243         spin_lock_init(&sbsp->smk_sblock);
244
245         sb->s_security = sbsp;
246
247         return 0;
248 }
249
250 /**
251  * smack_sb_free_security - free a superblock blob
252  * @sb: the superblock getting the blob
253  *
254  */
255 static void smack_sb_free_security(struct super_block *sb)
256 {
257         kfree(sb->s_security);
258         sb->s_security = NULL;
259 }
260
261 /**
262  * smack_sb_copy_data - copy mount options data for processing
263  * @orig: where to start
264  * @smackopts: mount options string
265  *
266  * Returns 0 on success or -ENOMEM on error.
267  *
268  * Copy the Smack specific mount options out of the mount
269  * options list.
270  */
271 static int smack_sb_copy_data(char *orig, char *smackopts)
272 {
273         char *cp, *commap, *otheropts, *dp;
274
275         otheropts = (char *)get_zeroed_page(GFP_KERNEL);
276         if (otheropts == NULL)
277                 return -ENOMEM;
278
279         for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
280                 if (strstr(cp, SMK_FSDEFAULT) == cp)
281                         dp = smackopts;
282                 else if (strstr(cp, SMK_FSFLOOR) == cp)
283                         dp = smackopts;
284                 else if (strstr(cp, SMK_FSHAT) == cp)
285                         dp = smackopts;
286                 else if (strstr(cp, SMK_FSROOT) == cp)
287                         dp = smackopts;
288                 else
289                         dp = otheropts;
290
291                 commap = strchr(cp, ',');
292                 if (commap != NULL)
293                         *commap = '\0';
294
295                 if (*dp != '\0')
296                         strcat(dp, ",");
297                 strcat(dp, cp);
298         }
299
300         strcpy(orig, otheropts);
301         free_page((unsigned long)otheropts);
302
303         return 0;
304 }
305
306 /**
307  * smack_sb_kern_mount - Smack specific mount processing
308  * @sb: the file system superblock
309  * @flags: the mount flags
310  * @data: the smack mount options
311  *
312  * Returns 0 on success, an error code on failure
313  */
314 static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
315 {
316         struct dentry *root = sb->s_root;
317         struct inode *inode = root->d_inode;
318         struct superblock_smack *sp = sb->s_security;
319         struct inode_smack *isp;
320         char *op;
321         char *commap;
322         char *nsp;
323
324         spin_lock(&sp->smk_sblock);
325         if (sp->smk_initialized != 0) {
326                 spin_unlock(&sp->smk_sblock);
327                 return 0;
328         }
329         sp->smk_initialized = 1;
330         spin_unlock(&sp->smk_sblock);
331
332         for (op = data; op != NULL; op = commap) {
333                 commap = strchr(op, ',');
334                 if (commap != NULL)
335                         *commap++ = '\0';
336
337                 if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) {
338                         op += strlen(SMK_FSHAT);
339                         nsp = smk_import(op, 0);
340                         if (nsp != NULL)
341                                 sp->smk_hat = nsp;
342                 } else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) {
343                         op += strlen(SMK_FSFLOOR);
344                         nsp = smk_import(op, 0);
345                         if (nsp != NULL)
346                                 sp->smk_floor = nsp;
347                 } else if (strncmp(op, SMK_FSDEFAULT,
348                                    strlen(SMK_FSDEFAULT)) == 0) {
349                         op += strlen(SMK_FSDEFAULT);
350                         nsp = smk_import(op, 0);
351                         if (nsp != NULL)
352                                 sp->smk_default = nsp;
353                 } else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) {
354                         op += strlen(SMK_FSROOT);
355                         nsp = smk_import(op, 0);
356                         if (nsp != NULL)
357                                 sp->smk_root = nsp;
358                 }
359         }
360
361         /*
362          * Initialize the root inode.
363          */
364         isp = inode->i_security;
365         if (isp == NULL)
366                 inode->i_security = new_inode_smack(sp->smk_root);
367         else
368                 isp->smk_inode = sp->smk_root;
369
370         return 0;
371 }
372
373 /**
374  * smack_sb_statfs - Smack check on statfs
375  * @dentry: identifies the file system in question
376  *
377  * Returns 0 if current can read the floor of the filesystem,
378  * and error code otherwise
379  */
380 static int smack_sb_statfs(struct dentry *dentry)
381 {
382         struct superblock_smack *sbp = dentry->d_sb->s_security;
383         int rc;
384         struct smk_audit_info ad;
385
386         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
387         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
388
389         rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad);
390         return rc;
391 }
392
393 /**
394  * smack_sb_mount - Smack check for mounting
395  * @dev_name: unused
396  * @path: mount point
397  * @type: unused
398  * @flags: unused
399  * @data: unused
400  *
401  * Returns 0 if current can write the floor of the filesystem
402  * being mounted on, an error code otherwise.
403  */
404 static int smack_sb_mount(char *dev_name, struct path *path,
405                           char *type, unsigned long flags, void *data)
406 {
407         struct superblock_smack *sbp = path->mnt->mnt_sb->s_security;
408         struct smk_audit_info ad;
409
410         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
411         smk_ad_setfield_u_fs_path(&ad, *path);
412
413         return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
414 }
415
416 /**
417  * smack_sb_umount - Smack check for unmounting
418  * @mnt: file system to unmount
419  * @flags: unused
420  *
421  * Returns 0 if current can write the floor of the filesystem
422  * being unmounted, an error code otherwise.
423  */
424 static int smack_sb_umount(struct vfsmount *mnt, int flags)
425 {
426         struct superblock_smack *sbp;
427         struct smk_audit_info ad;
428         struct path path;
429
430         path.dentry = mnt->mnt_root;
431         path.mnt = mnt;
432
433         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
434         smk_ad_setfield_u_fs_path(&ad, path);
435
436         sbp = mnt->mnt_sb->s_security;
437         return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
438 }
439
440 /*
441  * BPRM hooks
442  */
443
444 /**
445  * smack_bprm_set_creds - set creds for exec
446  * @bprm: the exec information
447  *
448  * Returns 0 if it gets a blob, -ENOMEM otherwise
449  */
450 static int smack_bprm_set_creds(struct linux_binprm *bprm)
451 {
452         struct task_smack *tsp = bprm->cred->security;
453         struct inode_smack *isp;
454         struct dentry *dp;
455         int rc;
456
457         rc = cap_bprm_set_creds(bprm);
458         if (rc != 0)
459                 return rc;
460
461         if (bprm->cred_prepared)
462                 return 0;
463
464         if (bprm->file == NULL || bprm->file->f_dentry == NULL)
465                 return 0;
466
467         dp = bprm->file->f_dentry;
468
469         if (dp->d_inode == NULL)
470                 return 0;
471
472         isp = dp->d_inode->i_security;
473
474         if (isp->smk_task != NULL)
475                 tsp->smk_task = isp->smk_task;
476
477         return 0;
478 }
479
480 /*
481  * Inode hooks
482  */
483
484 /**
485  * smack_inode_alloc_security - allocate an inode blob
486  * @inode: the inode in need of a blob
487  *
488  * Returns 0 if it gets a blob, -ENOMEM otherwise
489  */
490 static int smack_inode_alloc_security(struct inode *inode)
491 {
492         inode->i_security = new_inode_smack(smk_of_current());
493         if (inode->i_security == NULL)
494                 return -ENOMEM;
495         return 0;
496 }
497
498 /**
499  * smack_inode_free_security - free an inode blob
500  * @inode: the inode with a blob
501  *
502  * Clears the blob pointer in inode
503  */
504 static void smack_inode_free_security(struct inode *inode)
505 {
506         kfree(inode->i_security);
507         inode->i_security = NULL;
508 }
509
510 /**
511  * smack_inode_init_security - copy out the smack from an inode
512  * @inode: the inode
513  * @dir: unused
514  * @qstr: unused
515  * @name: where to put the attribute name
516  * @value: where to put the attribute value
517  * @len: where to put the length of the attribute
518  *
519  * Returns 0 if it all works out, -ENOMEM if there's no memory
520  */
521 static int smack_inode_init_security(struct inode *inode, struct inode *dir,
522                                      const struct qstr *qstr, char **name,
523                                      void **value, size_t *len)
524 {
525         struct smack_known *skp;
526         char *csp = smk_of_current();
527         char *isp = smk_of_inode(inode);
528         char *dsp = smk_of_inode(dir);
529         int may;
530
531         if (name) {
532                 *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_KERNEL);
533                 if (*name == NULL)
534                         return -ENOMEM;
535         }
536
537         if (value) {
538                 skp = smk_find_entry(csp);
539                 rcu_read_lock();
540                 may = smk_access_entry(csp, dsp, &skp->smk_rules);
541                 rcu_read_unlock();
542
543                 /*
544                  * If the access rule allows transmutation and
545                  * the directory requests transmutation then
546                  * by all means transmute.
547                  */
548                 if (may > 0 && ((may & MAY_TRANSMUTE) != 0) &&
549                     smk_inode_transmutable(dir))
550                         isp = dsp;
551
552                 *value = kstrdup(isp, GFP_KERNEL);
553                 if (*value == NULL)
554                         return -ENOMEM;
555         }
556
557         if (len)
558                 *len = strlen(isp) + 1;
559
560         return 0;
561 }
562
563 /**
564  * smack_inode_link - Smack check on link
565  * @old_dentry: the existing object
566  * @dir: unused
567  * @new_dentry: the new object
568  *
569  * Returns 0 if access is permitted, an error code otherwise
570  */
571 static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
572                             struct dentry *new_dentry)
573 {
574         char *isp;
575         struct smk_audit_info ad;
576         int rc;
577
578         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
579         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
580
581         isp = smk_of_inode(old_dentry->d_inode);
582         rc = smk_curacc(isp, MAY_WRITE, &ad);
583
584         if (rc == 0 && new_dentry->d_inode != NULL) {
585                 isp = smk_of_inode(new_dentry->d_inode);
586                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
587                 rc = smk_curacc(isp, MAY_WRITE, &ad);
588         }
589
590         return rc;
591 }
592
593 /**
594  * smack_inode_unlink - Smack check on inode deletion
595  * @dir: containing directory object
596  * @dentry: file to unlink
597  *
598  * Returns 0 if current can write the containing directory
599  * and the object, error code otherwise
600  */
601 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
602 {
603         struct inode *ip = dentry->d_inode;
604         struct smk_audit_info ad;
605         int rc;
606
607         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
608         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
609
610         /*
611          * You need write access to the thing you're unlinking
612          */
613         rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad);
614         if (rc == 0) {
615                 /*
616                  * You also need write access to the containing directory
617                  */
618                 smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
619                 smk_ad_setfield_u_fs_inode(&ad, dir);
620                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
621         }
622         return rc;
623 }
624
625 /**
626  * smack_inode_rmdir - Smack check on directory deletion
627  * @dir: containing directory object
628  * @dentry: directory to unlink
629  *
630  * Returns 0 if current can write the containing directory
631  * and the directory, error code otherwise
632  */
633 static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
634 {
635         struct smk_audit_info ad;
636         int rc;
637
638         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
639         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
640
641         /*
642          * You need write access to the thing you're removing
643          */
644         rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
645         if (rc == 0) {
646                 /*
647                  * You also need write access to the containing directory
648                  */
649                 smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
650                 smk_ad_setfield_u_fs_inode(&ad, dir);
651                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
652         }
653
654         return rc;
655 }
656
657 /**
658  * smack_inode_rename - Smack check on rename
659  * @old_inode: the old directory
660  * @old_dentry: unused
661  * @new_inode: the new directory
662  * @new_dentry: unused
663  *
664  * Read and write access is required on both the old and
665  * new directories.
666  *
667  * Returns 0 if access is permitted, an error code otherwise
668  */
669 static int smack_inode_rename(struct inode *old_inode,
670                               struct dentry *old_dentry,
671                               struct inode *new_inode,
672                               struct dentry *new_dentry)
673 {
674         int rc;
675         char *isp;
676         struct smk_audit_info ad;
677
678         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
679         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
680
681         isp = smk_of_inode(old_dentry->d_inode);
682         rc = smk_curacc(isp, MAY_READWRITE, &ad);
683
684         if (rc == 0 && new_dentry->d_inode != NULL) {
685                 isp = smk_of_inode(new_dentry->d_inode);
686                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
687                 rc = smk_curacc(isp, MAY_READWRITE, &ad);
688         }
689         return rc;
690 }
691
692 /**
693  * smack_inode_permission - Smack version of permission()
694  * @inode: the inode in question
695  * @mask: the access requested
696  *
697  * This is the important Smack hook.
698  *
699  * Returns 0 if access is permitted, -EACCES otherwise
700  */
701 static int smack_inode_permission(struct inode *inode, int mask)
702 {
703         struct smk_audit_info ad;
704         int no_block = mask & MAY_NOT_BLOCK;
705
706         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
707         /*
708          * No permission to check. Existence test. Yup, it's there.
709          */
710         if (mask == 0)
711                 return 0;
712
713         /* May be droppable after audit */
714         if (no_block)
715                 return -ECHILD;
716         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
717         smk_ad_setfield_u_fs_inode(&ad, inode);
718         return smk_curacc(smk_of_inode(inode), mask, &ad);
719 }
720
721 /**
722  * smack_inode_setattr - Smack check for setting attributes
723  * @dentry: the object
724  * @iattr: for the force flag
725  *
726  * Returns 0 if access is permitted, an error code otherwise
727  */
728 static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
729 {
730         struct smk_audit_info ad;
731         /*
732          * Need to allow for clearing the setuid bit.
733          */
734         if (iattr->ia_valid & ATTR_FORCE)
735                 return 0;
736         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
737         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
738
739         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
740 }
741
742 /**
743  * smack_inode_getattr - Smack check for getting attributes
744  * @mnt: unused
745  * @dentry: the object
746  *
747  * Returns 0 if access is permitted, an error code otherwise
748  */
749 static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
750 {
751         struct smk_audit_info ad;
752         struct path path;
753
754         path.dentry = dentry;
755         path.mnt = mnt;
756
757         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
758         smk_ad_setfield_u_fs_path(&ad, path);
759         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
760 }
761
762 /**
763  * smack_inode_setxattr - Smack check for setting xattrs
764  * @dentry: the object
765  * @name: name of the attribute
766  * @value: unused
767  * @size: unused
768  * @flags: unused
769  *
770  * This protects the Smack attribute explicitly.
771  *
772  * Returns 0 if access is permitted, an error code otherwise
773  */
774 static int smack_inode_setxattr(struct dentry *dentry, const char *name,
775                                 const void *value, size_t size, int flags)
776 {
777         struct smk_audit_info ad;
778         int rc = 0;
779
780         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
781             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
782             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
783             strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
784             strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
785                 if (!capable(CAP_MAC_ADMIN))
786                         rc = -EPERM;
787                 /*
788                  * check label validity here so import wont fail on
789                  * post_setxattr
790                  */
791                 if (size == 0 || size >= SMK_LABELLEN ||
792                     smk_import(value, size) == NULL)
793                         rc = -EINVAL;
794         } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
795                 if (!capable(CAP_MAC_ADMIN))
796                         rc = -EPERM;
797                 if (size != TRANS_TRUE_SIZE ||
798                     strncmp(value, TRANS_TRUE, TRANS_TRUE_SIZE) != 0)
799                         rc = -EINVAL;
800         } else
801                 rc = cap_inode_setxattr(dentry, name, value, size, flags);
802
803         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
804         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
805
806         if (rc == 0)
807                 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
808
809         return rc;
810 }
811
812 /**
813  * smack_inode_post_setxattr - Apply the Smack update approved above
814  * @dentry: object
815  * @name: attribute name
816  * @value: attribute value
817  * @size: attribute size
818  * @flags: unused
819  *
820  * Set the pointer in the inode blob to the entry found
821  * in the master label list.
822  */
823 static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
824                                       const void *value, size_t size, int flags)
825 {
826         char *nsp;
827         struct inode_smack *isp = dentry->d_inode->i_security;
828
829         if (strcmp(name, XATTR_NAME_SMACK) == 0) {
830                 nsp = smk_import(value, size);
831                 if (nsp != NULL)
832                         isp->smk_inode = nsp;
833                 else
834                         isp->smk_inode = smack_known_invalid.smk_known;
835         } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0) {
836                 nsp = smk_import(value, size);
837                 if (nsp != NULL)
838                         isp->smk_task = nsp;
839                 else
840                         isp->smk_task = smack_known_invalid.smk_known;
841         } else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
842                 nsp = smk_import(value, size);
843                 if (nsp != NULL)
844                         isp->smk_mmap = nsp;
845                 else
846                         isp->smk_mmap = smack_known_invalid.smk_known;
847         } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0)
848                 isp->smk_flags |= SMK_INODE_TRANSMUTE;
849
850         return;
851 }
852
853 /**
854  * smack_inode_getxattr - Smack check on getxattr
855  * @dentry: the object
856  * @name: unused
857  *
858  * Returns 0 if access is permitted, an error code otherwise
859  */
860 static int smack_inode_getxattr(struct dentry *dentry, const char *name)
861 {
862         struct smk_audit_info ad;
863
864         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
865         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
866
867         return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
868 }
869
870 /**
871  * smack_inode_removexattr - Smack check on removexattr
872  * @dentry: the object
873  * @name: name of the attribute
874  *
875  * Removing the Smack attribute requires CAP_MAC_ADMIN
876  *
877  * Returns 0 if access is permitted, an error code otherwise
878  */
879 static int smack_inode_removexattr(struct dentry *dentry, const char *name)
880 {
881         struct inode_smack *isp;
882         struct smk_audit_info ad;
883         int rc = 0;
884
885         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
886             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
887             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
888             strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
889             strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 ||
890             strcmp(name, XATTR_NAME_SMACKMMAP)) {
891                 if (!capable(CAP_MAC_ADMIN))
892                         rc = -EPERM;
893         } else
894                 rc = cap_inode_removexattr(dentry, name);
895
896         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
897         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
898         if (rc == 0)
899                 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
900
901         if (rc == 0) {
902                 isp = dentry->d_inode->i_security;
903                 isp->smk_task = NULL;
904                 isp->smk_mmap = NULL;
905         }
906
907         return rc;
908 }
909
910 /**
911  * smack_inode_getsecurity - get smack xattrs
912  * @inode: the object
913  * @name: attribute name
914  * @buffer: where to put the result
915  * @alloc: unused
916  *
917  * Returns the size of the attribute or an error code
918  */
919 static int smack_inode_getsecurity(const struct inode *inode,
920                                    const char *name, void **buffer,
921                                    bool alloc)
922 {
923         struct socket_smack *ssp;
924         struct socket *sock;
925         struct super_block *sbp;
926         struct inode *ip = (struct inode *)inode;
927         char *isp;
928         int ilen;
929         int rc = 0;
930
931         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
932                 isp = smk_of_inode(inode);
933                 ilen = strlen(isp) + 1;
934                 *buffer = isp;
935                 return ilen;
936         }
937
938         /*
939          * The rest of the Smack xattrs are only on sockets.
940          */
941         sbp = ip->i_sb;
942         if (sbp->s_magic != SOCKFS_MAGIC)
943                 return -EOPNOTSUPP;
944
945         sock = SOCKET_I(ip);
946         if (sock == NULL || sock->sk == NULL)
947                 return -EOPNOTSUPP;
948
949         ssp = sock->sk->sk_security;
950
951         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
952                 isp = ssp->smk_in;
953         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
954                 isp = ssp->smk_out;
955         else
956                 return -EOPNOTSUPP;
957
958         ilen = strlen(isp) + 1;
959         if (rc == 0) {
960                 *buffer = isp;
961                 rc = ilen;
962         }
963
964         return rc;
965 }
966
967
968 /**
969  * smack_inode_listsecurity - list the Smack attributes
970  * @inode: the object
971  * @buffer: where they go
972  * @buffer_size: size of buffer
973  *
974  * Returns 0 on success, -EINVAL otherwise
975  */
976 static int smack_inode_listsecurity(struct inode *inode, char *buffer,
977                                     size_t buffer_size)
978 {
979         int len = strlen(XATTR_NAME_SMACK);
980
981         if (buffer != NULL && len <= buffer_size) {
982                 memcpy(buffer, XATTR_NAME_SMACK, len);
983                 return len;
984         }
985         return -EINVAL;
986 }
987
988 /**
989  * smack_inode_getsecid - Extract inode's security id
990  * @inode: inode to extract the info from
991  * @secid: where result will be saved
992  */
993 static void smack_inode_getsecid(const struct inode *inode, u32 *secid)
994 {
995         struct inode_smack *isp = inode->i_security;
996
997         *secid = smack_to_secid(isp->smk_inode);
998 }
999
1000 /*
1001  * File Hooks
1002  */
1003
1004 /**
1005  * smack_file_permission - Smack check on file operations
1006  * @file: unused
1007  * @mask: unused
1008  *
1009  * Returns 0
1010  *
1011  * Should access checks be done on each read or write?
1012  * UNICOS and SELinux say yes.
1013  * Trusted Solaris, Trusted Irix, and just about everyone else says no.
1014  *
1015  * I'll say no for now. Smack does not do the frequent
1016  * label changing that SELinux does.
1017  */
1018 static int smack_file_permission(struct file *file, int mask)
1019 {
1020         return 0;
1021 }
1022
1023 /**
1024  * smack_file_alloc_security - assign a file security blob
1025  * @file: the object
1026  *
1027  * The security blob for a file is a pointer to the master
1028  * label list, so no allocation is done.
1029  *
1030  * Returns 0
1031  */
1032 static int smack_file_alloc_security(struct file *file)
1033 {
1034         file->f_security = smk_of_current();
1035         return 0;
1036 }
1037
1038 /**
1039  * smack_file_free_security - clear a file security blob
1040  * @file: the object
1041  *
1042  * The security blob for a file is a pointer to the master
1043  * label list, so no memory is freed.
1044  */
1045 static void smack_file_free_security(struct file *file)
1046 {
1047         file->f_security = NULL;
1048 }
1049
1050 /**
1051  * smack_file_ioctl - Smack check on ioctls
1052  * @file: the object
1053  * @cmd: what to do
1054  * @arg: unused
1055  *
1056  * Relies heavily on the correct use of the ioctl command conventions.
1057  *
1058  * Returns 0 if allowed, error code otherwise
1059  */
1060 static int smack_file_ioctl(struct file *file, unsigned int cmd,
1061                             unsigned long arg)
1062 {
1063         int rc = 0;
1064         struct smk_audit_info ad;
1065
1066         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1067         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1068
1069         if (_IOC_DIR(cmd) & _IOC_WRITE)
1070                 rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1071
1072         if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
1073                 rc = smk_curacc(file->f_security, MAY_READ, &ad);
1074
1075         return rc;
1076 }
1077
1078 /**
1079  * smack_file_lock - Smack check on file locking
1080  * @file: the object
1081  * @cmd: unused
1082  *
1083  * Returns 0 if current has write access, error code otherwise
1084  */
1085 static int smack_file_lock(struct file *file, unsigned int cmd)
1086 {
1087         struct smk_audit_info ad;
1088
1089         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1090         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1091         return smk_curacc(file->f_security, MAY_WRITE, &ad);
1092 }
1093
1094 /**
1095  * smack_file_fcntl - Smack check on fcntl
1096  * @file: the object
1097  * @cmd: what action to check
1098  * @arg: unused
1099  *
1100  * Generally these operations are harmless.
1101  * File locking operations present an obvious mechanism
1102  * for passing information, so they require write access.
1103  *
1104  * Returns 0 if current has access, error code otherwise
1105  */
1106 static int smack_file_fcntl(struct file *file, unsigned int cmd,
1107                             unsigned long arg)
1108 {
1109         struct smk_audit_info ad;
1110         int rc = 0;
1111
1112
1113         switch (cmd) {
1114         case F_GETLK:
1115         case F_SETLK:
1116         case F_SETLKW:
1117         case F_SETOWN:
1118         case F_SETSIG:
1119                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1120                 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1121                 rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1122                 break;
1123         default:
1124                 break;
1125         }
1126
1127         return rc;
1128 }
1129
1130 /**
1131  * smack_file_mmap :
1132  * Check permissions for a mmap operation.  The @file may be NULL, e.g.
1133  * if mapping anonymous memory.
1134  * @file contains the file structure for file to map (may be NULL).
1135  * @reqprot contains the protection requested by the application.
1136  * @prot contains the protection that will be applied by the kernel.
1137  * @flags contains the operational flags.
1138  * Return 0 if permission is granted.
1139  */
1140 static int smack_file_mmap(struct file *file,
1141                            unsigned long reqprot, unsigned long prot,
1142                            unsigned long flags, unsigned long addr,
1143                            unsigned long addr_only)
1144 {
1145         struct smack_known *skp;
1146         struct smack_rule *srp;
1147         struct task_smack *tsp;
1148         char *sp;
1149         char *msmack;
1150         char *osmack;
1151         struct inode_smack *isp;
1152         struct dentry *dp;
1153         int may;
1154         int mmay;
1155         int tmay;
1156         int rc;
1157
1158         /* do DAC check on address space usage */
1159         rc = cap_file_mmap(file, reqprot, prot, flags, addr, addr_only);
1160         if (rc || addr_only)
1161                 return rc;
1162
1163         if (file == NULL || file->f_dentry == NULL)
1164                 return 0;
1165
1166         dp = file->f_dentry;
1167
1168         if (dp->d_inode == NULL)
1169                 return 0;
1170
1171         isp = dp->d_inode->i_security;
1172         if (isp->smk_mmap == NULL)
1173                 return 0;
1174         msmack = isp->smk_mmap;
1175
1176         tsp = current_security();
1177         sp = smk_of_current();
1178         skp = smk_find_entry(sp);
1179         rc = 0;
1180
1181         rcu_read_lock();
1182         /*
1183          * For each Smack rule associated with the subject
1184          * label verify that the SMACK64MMAP also has access
1185          * to that rule's object label.
1186          */
1187         list_for_each_entry_rcu(srp, &skp->smk_rules, list) {
1188                 osmack = srp->smk_object;
1189                 /*
1190                  * Matching labels always allows access.
1191                  */
1192                 if (msmack == osmack)
1193                         continue;
1194                 /*
1195                  * If there is a matching local rule take
1196                  * that into account as well.
1197                  */
1198                 may = smk_access_entry(srp->smk_subject, osmack,
1199                                         &tsp->smk_rules);
1200                 if (may == -ENOENT)
1201                         may = srp->smk_access;
1202                 else
1203                         may &= srp->smk_access;
1204                 /*
1205                  * If may is zero the SMACK64MMAP subject can't
1206                  * possibly have less access.
1207                  */
1208                 if (may == 0)
1209                         continue;
1210
1211                 /*
1212                  * Fetch the global list entry.
1213                  * If there isn't one a SMACK64MMAP subject
1214                  * can't have as much access as current.
1215                  */
1216                 skp = smk_find_entry(msmack);
1217                 mmay = smk_access_entry(msmack, osmack, &skp->smk_rules);
1218                 if (mmay == -ENOENT) {
1219                         rc = -EACCES;
1220                         break;
1221                 }
1222                 /*
1223                  * If there is a local entry it modifies the
1224                  * potential access, too.
1225                  */
1226                 tmay = smk_access_entry(msmack, osmack, &tsp->smk_rules);
1227                 if (tmay != -ENOENT)
1228                         mmay &= tmay;
1229
1230                 /*
1231                  * If there is any access available to current that is
1232                  * not available to a SMACK64MMAP subject
1233                  * deny access.
1234                  */
1235                 if ((may | mmay) != mmay) {
1236                         rc = -EACCES;
1237                         break;
1238                 }
1239         }
1240
1241         rcu_read_unlock();
1242
1243         return rc;
1244 }
1245
1246 /**
1247  * smack_file_set_fowner - set the file security blob value
1248  * @file: object in question
1249  *
1250  * Returns 0
1251  * Further research may be required on this one.
1252  */
1253 static int smack_file_set_fowner(struct file *file)
1254 {
1255         file->f_security = smk_of_current();
1256         return 0;
1257 }
1258
1259 /**
1260  * smack_file_send_sigiotask - Smack on sigio
1261  * @tsk: The target task
1262  * @fown: the object the signal come from
1263  * @signum: unused
1264  *
1265  * Allow a privileged task to get signals even if it shouldn't
1266  *
1267  * Returns 0 if a subject with the object's smack could
1268  * write to the task, an error code otherwise.
1269  */
1270 static int smack_file_send_sigiotask(struct task_struct *tsk,
1271                                      struct fown_struct *fown, int signum)
1272 {
1273         struct file *file;
1274         int rc;
1275         char *tsp = smk_of_task(tsk->cred->security);
1276         struct smk_audit_info ad;
1277
1278         /*
1279          * struct fown_struct is never outside the context of a struct file
1280          */
1281         file = container_of(fown, struct file, f_owner);
1282
1283         /* we don't log here as rc can be overriden */
1284         rc = smk_access(file->f_security, tsp, MAY_WRITE, NULL);
1285         if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE))
1286                 rc = 0;
1287
1288         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1289         smk_ad_setfield_u_tsk(&ad, tsk);
1290         smack_log(file->f_security, tsp, MAY_WRITE, rc, &ad);
1291         return rc;
1292 }
1293
1294 /**
1295  * smack_file_receive - Smack file receive check
1296  * @file: the object
1297  *
1298  * Returns 0 if current has access, error code otherwise
1299  */
1300 static int smack_file_receive(struct file *file)
1301 {
1302         int may = 0;
1303         struct smk_audit_info ad;
1304
1305         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1306         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1307         /*
1308          * This code relies on bitmasks.
1309          */
1310         if (file->f_mode & FMODE_READ)
1311                 may = MAY_READ;
1312         if (file->f_mode & FMODE_WRITE)
1313                 may |= MAY_WRITE;
1314
1315         return smk_curacc(file->f_security, may, &ad);
1316 }
1317
1318 /**
1319  * smack_dentry_open - Smack dentry open processing
1320  * @file: the object
1321  * @cred: unused
1322  *
1323  * Set the security blob in the file structure.
1324  *
1325  * Returns 0
1326  */
1327 static int smack_dentry_open(struct file *file, const struct cred *cred)
1328 {
1329         struct inode_smack *isp = file->f_path.dentry->d_inode->i_security;
1330
1331         file->f_security = isp->smk_inode;
1332
1333         return 0;
1334 }
1335
1336 /*
1337  * Task hooks
1338  */
1339
1340 /**
1341  * smack_cred_alloc_blank - "allocate" blank task-level security credentials
1342  * @new: the new credentials
1343  * @gfp: the atomicity of any memory allocations
1344  *
1345  * Prepare a blank set of credentials for modification.  This must allocate all
1346  * the memory the LSM module might require such that cred_transfer() can
1347  * complete without error.
1348  */
1349 static int smack_cred_alloc_blank(struct cred *cred, gfp_t gfp)
1350 {
1351         struct task_smack *tsp;
1352
1353         tsp = new_task_smack(NULL, NULL, gfp);
1354         if (tsp == NULL)
1355                 return -ENOMEM;
1356
1357         cred->security = tsp;
1358
1359         return 0;
1360 }
1361
1362
1363 /**
1364  * smack_cred_free - "free" task-level security credentials
1365  * @cred: the credentials in question
1366  *
1367  */
1368 static void smack_cred_free(struct cred *cred)
1369 {
1370         struct task_smack *tsp = cred->security;
1371         struct smack_rule *rp;
1372         struct list_head *l;
1373         struct list_head *n;
1374
1375         if (tsp == NULL)
1376                 return;
1377         cred->security = NULL;
1378
1379         list_for_each_safe(l, n, &tsp->smk_rules) {
1380                 rp = list_entry(l, struct smack_rule, list);
1381                 list_del(&rp->list);
1382                 kfree(rp);
1383         }
1384         kfree(tsp);
1385 }
1386
1387 /**
1388  * smack_cred_prepare - prepare new set of credentials for modification
1389  * @new: the new credentials
1390  * @old: the original credentials
1391  * @gfp: the atomicity of any memory allocations
1392  *
1393  * Prepare a new set of credentials for modification.
1394  */
1395 static int smack_cred_prepare(struct cred *new, const struct cred *old,
1396                               gfp_t gfp)
1397 {
1398         struct task_smack *old_tsp = old->security;
1399         struct task_smack *new_tsp;
1400         int rc;
1401
1402         new_tsp = new_task_smack(old_tsp->smk_task, old_tsp->smk_task, gfp);
1403         if (new_tsp == NULL)
1404                 return -ENOMEM;
1405
1406         rc = smk_copy_rules(&new_tsp->smk_rules, &old_tsp->smk_rules, gfp);
1407         if (rc != 0)
1408                 return rc;
1409
1410         new->security = new_tsp;
1411         return 0;
1412 }
1413
1414 /**
1415  * smack_cred_transfer - Transfer the old credentials to the new credentials
1416  * @new: the new credentials
1417  * @old: the original credentials
1418  *
1419  * Fill in a set of blank credentials from another set of credentials.
1420  */
1421 static void smack_cred_transfer(struct cred *new, const struct cred *old)
1422 {
1423         struct task_smack *old_tsp = old->security;
1424         struct task_smack *new_tsp = new->security;
1425
1426         new_tsp->smk_task = old_tsp->smk_task;
1427         new_tsp->smk_forked = old_tsp->smk_task;
1428         mutex_init(&new_tsp->smk_rules_lock);
1429         INIT_LIST_HEAD(&new_tsp->smk_rules);
1430
1431
1432         /* cbs copy rule list */
1433 }
1434
1435 /**
1436  * smack_kernel_act_as - Set the subjective context in a set of credentials
1437  * @new: points to the set of credentials to be modified.
1438  * @secid: specifies the security ID to be set
1439  *
1440  * Set the security data for a kernel service.
1441  */
1442 static int smack_kernel_act_as(struct cred *new, u32 secid)
1443 {
1444         struct task_smack *new_tsp = new->security;
1445         char *smack = smack_from_secid(secid);
1446
1447         if (smack == NULL)
1448                 return -EINVAL;
1449
1450         new_tsp->smk_task = smack;
1451         return 0;
1452 }
1453
1454 /**
1455  * smack_kernel_create_files_as - Set the file creation label in a set of creds
1456  * @new: points to the set of credentials to be modified
1457  * @inode: points to the inode to use as a reference
1458  *
1459  * Set the file creation context in a set of credentials to the same
1460  * as the objective context of the specified inode
1461  */
1462 static int smack_kernel_create_files_as(struct cred *new,
1463                                         struct inode *inode)
1464 {
1465         struct inode_smack *isp = inode->i_security;
1466         struct task_smack *tsp = new->security;
1467
1468         tsp->smk_forked = isp->smk_inode;
1469         tsp->smk_task = isp->smk_inode;
1470         return 0;
1471 }
1472
1473 /**
1474  * smk_curacc_on_task - helper to log task related access
1475  * @p: the task object
1476  * @access: the access requested
1477  * @caller: name of the calling function for audit
1478  *
1479  * Return 0 if access is permitted
1480  */
1481 static int smk_curacc_on_task(struct task_struct *p, int access,
1482                                 const char *caller)
1483 {
1484         struct smk_audit_info ad;
1485
1486         smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK);
1487         smk_ad_setfield_u_tsk(&ad, p);
1488         return smk_curacc(smk_of_task(task_security(p)), access, &ad);
1489 }
1490
1491 /**
1492  * smack_task_setpgid - Smack check on setting pgid
1493  * @p: the task object
1494  * @pgid: unused
1495  *
1496  * Return 0 if write access is permitted
1497  */
1498 static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
1499 {
1500         return smk_curacc_on_task(p, MAY_WRITE, __func__);
1501 }
1502
1503 /**
1504  * smack_task_getpgid - Smack access check for getpgid
1505  * @p: the object task
1506  *
1507  * Returns 0 if current can read the object task, error code otherwise
1508  */
1509 static int smack_task_getpgid(struct task_struct *p)
1510 {
1511         return smk_curacc_on_task(p, MAY_READ, __func__);
1512 }
1513
1514 /**
1515  * smack_task_getsid - Smack access check for getsid
1516  * @p: the object task
1517  *
1518  * Returns 0 if current can read the object task, error code otherwise
1519  */
1520 static int smack_task_getsid(struct task_struct *p)
1521 {
1522         return smk_curacc_on_task(p, MAY_READ, __func__);
1523 }
1524
1525 /**
1526  * smack_task_getsecid - get the secid of the task
1527  * @p: the object task
1528  * @secid: where to put the result
1529  *
1530  * Sets the secid to contain a u32 version of the smack label.
1531  */
1532 static void smack_task_getsecid(struct task_struct *p, u32 *secid)
1533 {
1534         *secid = smack_to_secid(smk_of_task(task_security(p)));
1535 }
1536
1537 /**
1538  * smack_task_setnice - Smack check on setting nice
1539  * @p: the task object
1540  * @nice: unused
1541  *
1542  * Return 0 if write access is permitted
1543  */
1544 static int smack_task_setnice(struct task_struct *p, int nice)
1545 {
1546         int rc;
1547
1548         rc = cap_task_setnice(p, nice);
1549         if (rc == 0)
1550                 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1551         return rc;
1552 }
1553
1554 /**
1555  * smack_task_setioprio - Smack check on setting ioprio
1556  * @p: the task object
1557  * @ioprio: unused
1558  *
1559  * Return 0 if write access is permitted
1560  */
1561 static int smack_task_setioprio(struct task_struct *p, int ioprio)
1562 {
1563         int rc;
1564
1565         rc = cap_task_setioprio(p, ioprio);
1566         if (rc == 0)
1567                 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1568         return rc;
1569 }
1570
1571 /**
1572  * smack_task_getioprio - Smack check on reading ioprio
1573  * @p: the task object
1574  *
1575  * Return 0 if read access is permitted
1576  */
1577 static int smack_task_getioprio(struct task_struct *p)
1578 {
1579         return smk_curacc_on_task(p, MAY_READ, __func__);
1580 }
1581
1582 /**
1583  * smack_task_setscheduler - Smack check on setting scheduler
1584  * @p: the task object
1585  * @policy: unused
1586  * @lp: unused
1587  *
1588  * Return 0 if read access is permitted
1589  */
1590 static int smack_task_setscheduler(struct task_struct *p)
1591 {
1592         int rc;
1593
1594         rc = cap_task_setscheduler(p);
1595         if (rc == 0)
1596                 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1597         return rc;
1598 }
1599
1600 /**
1601  * smack_task_getscheduler - Smack check on reading scheduler
1602  * @p: the task object
1603  *
1604  * Return 0 if read access is permitted
1605  */
1606 static int smack_task_getscheduler(struct task_struct *p)
1607 {
1608         return smk_curacc_on_task(p, MAY_READ, __func__);
1609 }
1610
1611 /**
1612  * smack_task_movememory - Smack check on moving memory
1613  * @p: the task object
1614  *
1615  * Return 0 if write access is permitted
1616  */
1617 static int smack_task_movememory(struct task_struct *p)
1618 {
1619         return smk_curacc_on_task(p, MAY_WRITE, __func__);
1620 }
1621
1622 /**
1623  * smack_task_kill - Smack check on signal delivery
1624  * @p: the task object
1625  * @info: unused
1626  * @sig: unused
1627  * @secid: identifies the smack to use in lieu of current's
1628  *
1629  * Return 0 if write access is permitted
1630  *
1631  * The secid behavior is an artifact of an SELinux hack
1632  * in the USB code. Someday it may go away.
1633  */
1634 static int smack_task_kill(struct task_struct *p, struct siginfo *info,
1635                            int sig, u32 secid)
1636 {
1637         struct smk_audit_info ad;
1638
1639         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1640         smk_ad_setfield_u_tsk(&ad, p);
1641         /*
1642          * Sending a signal requires that the sender
1643          * can write the receiver.
1644          */
1645         if (secid == 0)
1646                 return smk_curacc(smk_of_task(task_security(p)), MAY_WRITE,
1647                                   &ad);
1648         /*
1649          * If the secid isn't 0 we're dealing with some USB IO
1650          * specific behavior. This is not clean. For one thing
1651          * we can't take privilege into account.
1652          */
1653         return smk_access(smack_from_secid(secid),
1654                           smk_of_task(task_security(p)), MAY_WRITE, &ad);
1655 }
1656
1657 /**
1658  * smack_task_wait - Smack access check for waiting
1659  * @p: task to wait for
1660  *
1661  * Returns 0 if current can wait for p, error code otherwise
1662  */
1663 static int smack_task_wait(struct task_struct *p)
1664 {
1665         struct smk_audit_info ad;
1666         char *sp = smk_of_current();
1667         char *tsp = smk_of_forked(task_security(p));
1668         int rc;
1669
1670         /* we don't log here, we can be overriden */
1671         rc = smk_access(tsp, sp, MAY_WRITE, NULL);
1672         if (rc == 0)
1673                 goto out_log;
1674
1675         /*
1676          * Allow the operation to succeed if either task
1677          * has privilege to perform operations that might
1678          * account for the smack labels having gotten to
1679          * be different in the first place.
1680          *
1681          * This breaks the strict subject/object access
1682          * control ideal, taking the object's privilege
1683          * state into account in the decision as well as
1684          * the smack value.
1685          */
1686         if (capable(CAP_MAC_OVERRIDE) || has_capability(p, CAP_MAC_OVERRIDE))
1687                 rc = 0;
1688         /* we log only if we didn't get overriden */
1689  out_log:
1690         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1691         smk_ad_setfield_u_tsk(&ad, p);
1692         smack_log(tsp, sp, MAY_WRITE, rc, &ad);
1693         return rc;
1694 }
1695
1696 /**
1697  * smack_task_to_inode - copy task smack into the inode blob
1698  * @p: task to copy from
1699  * @inode: inode to copy to
1700  *
1701  * Sets the smack pointer in the inode security blob
1702  */
1703 static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
1704 {
1705         struct inode_smack *isp = inode->i_security;
1706         isp->smk_inode = smk_of_task(task_security(p));
1707 }
1708
1709 /*
1710  * Socket hooks.
1711  */
1712
1713 /**
1714  * smack_sk_alloc_security - Allocate a socket blob
1715  * @sk: the socket
1716  * @family: unused
1717  * @gfp_flags: memory allocation flags
1718  *
1719  * Assign Smack pointers to current
1720  *
1721  * Returns 0 on success, -ENOMEM is there's no memory
1722  */
1723 static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
1724 {
1725         char *csp = smk_of_current();
1726         struct socket_smack *ssp;
1727
1728         ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
1729         if (ssp == NULL)
1730                 return -ENOMEM;
1731
1732         ssp->smk_in = csp;
1733         ssp->smk_out = csp;
1734         ssp->smk_packet = NULL;
1735
1736         sk->sk_security = ssp;
1737
1738         return 0;
1739 }
1740
1741 /**
1742  * smack_sk_free_security - Free a socket blob
1743  * @sk: the socket
1744  *
1745  * Clears the blob pointer
1746  */
1747 static void smack_sk_free_security(struct sock *sk)
1748 {
1749         kfree(sk->sk_security);
1750 }
1751
1752 /**
1753 * smack_host_label - check host based restrictions
1754 * @sip: the object end
1755 *
1756 * looks for host based access restrictions
1757 *
1758 * This version will only be appropriate for really small sets of single label
1759 * hosts.  The caller is responsible for ensuring that the RCU read lock is
1760 * taken before calling this function.
1761 *
1762 * Returns the label of the far end or NULL if it's not special.
1763 */
1764 static char *smack_host_label(struct sockaddr_in *sip)
1765 {
1766         struct smk_netlbladdr *snp;
1767         struct in_addr *siap = &sip->sin_addr;
1768
1769         if (siap->s_addr == 0)
1770                 return NULL;
1771
1772         list_for_each_entry_rcu(snp, &smk_netlbladdr_list, list)
1773                 /*
1774                 * we break after finding the first match because
1775                 * the list is sorted from longest to shortest mask
1776                 * so we have found the most specific match
1777                 */
1778                 if ((&snp->smk_host.sin_addr)->s_addr ==
1779                     (siap->s_addr & (&snp->smk_mask)->s_addr)) {
1780                         /* we have found the special CIPSO option */
1781                         if (snp->smk_label == smack_cipso_option)
1782                                 return NULL;
1783                         return snp->smk_label;
1784                 }
1785
1786         return NULL;
1787 }
1788
1789 /**
1790  * smack_set_catset - convert a capset to netlabel mls categories
1791  * @catset: the Smack categories
1792  * @sap: where to put the netlabel categories
1793  *
1794  * Allocates and fills attr.mls.cat
1795  */
1796 static void smack_set_catset(char *catset, struct netlbl_lsm_secattr *sap)
1797 {
1798         unsigned char *cp;
1799         unsigned char m;
1800         int cat;
1801         int rc;
1802         int byte;
1803
1804         if (!catset)
1805                 return;
1806
1807         sap->flags |= NETLBL_SECATTR_MLS_CAT;
1808         sap->attr.mls.cat = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
1809         sap->attr.mls.cat->startbit = 0;
1810
1811         for (cat = 1, cp = catset, byte = 0; byte < SMK_LABELLEN; cp++, byte++)
1812                 for (m = 0x80; m != 0; m >>= 1, cat++) {
1813                         if ((m & *cp) == 0)
1814                                 continue;
1815                         rc = netlbl_secattr_catmap_setbit(sap->attr.mls.cat,
1816                                                           cat, GFP_ATOMIC);
1817                 }
1818 }
1819
1820 /**
1821  * smack_to_secattr - fill a secattr from a smack value
1822  * @smack: the smack value
1823  * @nlsp: where the result goes
1824  *
1825  * Casey says that CIPSO is good enough for now.
1826  * It can be used to effect.
1827  * It can also be abused to effect when necessary.
1828  * Apologies to the TSIG group in general and GW in particular.
1829  */
1830 static void smack_to_secattr(char *smack, struct netlbl_lsm_secattr *nlsp)
1831 {
1832         struct smack_cipso cipso;
1833         int rc;
1834
1835         nlsp->domain = smack;
1836         nlsp->flags = NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
1837
1838         rc = smack_to_cipso(smack, &cipso);
1839         if (rc == 0) {
1840                 nlsp->attr.mls.lvl = cipso.smk_level;
1841                 smack_set_catset(cipso.smk_catset, nlsp);
1842         } else {
1843                 nlsp->attr.mls.lvl = smack_cipso_direct;
1844                 smack_set_catset(smack, nlsp);
1845         }
1846 }
1847
1848 /**
1849  * smack_netlabel - Set the secattr on a socket
1850  * @sk: the socket
1851  * @labeled: socket label scheme
1852  *
1853  * Convert the outbound smack value (smk_out) to a
1854  * secattr and attach it to the socket.
1855  *
1856  * Returns 0 on success or an error code
1857  */
1858 static int smack_netlabel(struct sock *sk, int labeled)
1859 {
1860         struct socket_smack *ssp = sk->sk_security;
1861         struct netlbl_lsm_secattr secattr;
1862         int rc = 0;
1863
1864         /*
1865          * Usually the netlabel code will handle changing the
1866          * packet labeling based on the label.
1867          * The case of a single label host is different, because
1868          * a single label host should never get a labeled packet
1869          * even though the label is usually associated with a packet
1870          * label.
1871          */
1872         local_bh_disable();
1873         bh_lock_sock_nested(sk);
1874
1875         if (ssp->smk_out == smack_net_ambient ||
1876             labeled == SMACK_UNLABELED_SOCKET)
1877                 netlbl_sock_delattr(sk);
1878         else {
1879                 netlbl_secattr_init(&secattr);
1880                 smack_to_secattr(ssp->smk_out, &secattr);
1881                 rc = netlbl_sock_setattr(sk, sk->sk_family, &secattr);
1882                 netlbl_secattr_destroy(&secattr);
1883         }
1884
1885         bh_unlock_sock(sk);
1886         local_bh_enable();
1887
1888         return rc;
1889 }
1890
1891 /**
1892  * smack_netlbel_send - Set the secattr on a socket and perform access checks
1893  * @sk: the socket
1894  * @sap: the destination address
1895  *
1896  * Set the correct secattr for the given socket based on the destination
1897  * address and perform any outbound access checks needed.
1898  *
1899  * Returns 0 on success or an error code.
1900  *
1901  */
1902 static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
1903 {
1904         int rc;
1905         int sk_lbl;
1906         char *hostsp;
1907         struct socket_smack *ssp = sk->sk_security;
1908         struct smk_audit_info ad;
1909
1910         rcu_read_lock();
1911         hostsp = smack_host_label(sap);
1912         if (hostsp != NULL) {
1913                 sk_lbl = SMACK_UNLABELED_SOCKET;
1914 #ifdef CONFIG_AUDIT
1915                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
1916                 ad.a.u.net.family = sap->sin_family;
1917                 ad.a.u.net.dport = sap->sin_port;
1918                 ad.a.u.net.v4info.daddr = sap->sin_addr.s_addr;
1919 #endif
1920                 rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE, &ad);
1921         } else {
1922                 sk_lbl = SMACK_CIPSO_SOCKET;
1923                 rc = 0;
1924         }
1925         rcu_read_unlock();
1926         if (rc != 0)
1927                 return rc;
1928
1929         return smack_netlabel(sk, sk_lbl);
1930 }
1931
1932 /**
1933  * smack_inode_setsecurity - set smack xattrs
1934  * @inode: the object
1935  * @name: attribute name
1936  * @value: attribute value
1937  * @size: size of the attribute
1938  * @flags: unused
1939  *
1940  * Sets the named attribute in the appropriate blob
1941  *
1942  * Returns 0 on success, or an error code
1943  */
1944 static int smack_inode_setsecurity(struct inode *inode, const char *name,
1945                                    const void *value, size_t size, int flags)
1946 {
1947         char *sp;
1948         struct inode_smack *nsp = inode->i_security;
1949         struct socket_smack *ssp;
1950         struct socket *sock;
1951         int rc = 0;
1952
1953         if (value == NULL || size > SMK_LABELLEN || size == 0)
1954                 return -EACCES;
1955
1956         sp = smk_import(value, size);
1957         if (sp == NULL)
1958                 return -EINVAL;
1959
1960         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
1961                 nsp->smk_inode = sp;
1962                 nsp->smk_flags |= SMK_INODE_INSTANT;
1963                 return 0;
1964         }
1965         /*
1966          * The rest of the Smack xattrs are only on sockets.
1967          */
1968         if (inode->i_sb->s_magic != SOCKFS_MAGIC)
1969                 return -EOPNOTSUPP;
1970
1971         sock = SOCKET_I(inode);
1972         if (sock == NULL || sock->sk == NULL)
1973                 return -EOPNOTSUPP;
1974
1975         ssp = sock->sk->sk_security;
1976
1977         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
1978                 ssp->smk_in = sp;
1979         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
1980                 ssp->smk_out = sp;
1981                 if (sock->sk->sk_family != PF_UNIX) {
1982                         rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
1983                         if (rc != 0)
1984                                 printk(KERN_WARNING
1985                                         "Smack: \"%s\" netlbl error %d.\n",
1986                                         __func__, -rc);
1987                 }
1988         } else
1989                 return -EOPNOTSUPP;
1990
1991         return 0;
1992 }
1993
1994 /**
1995  * smack_socket_post_create - finish socket setup
1996  * @sock: the socket
1997  * @family: protocol family
1998  * @type: unused
1999  * @protocol: unused
2000  * @kern: unused
2001  *
2002  * Sets the netlabel information on the socket
2003  *
2004  * Returns 0 on success, and error code otherwise
2005  */
2006 static int smack_socket_post_create(struct socket *sock, int family,
2007                                     int type, int protocol, int kern)
2008 {
2009         if (family != PF_INET || sock->sk == NULL)
2010                 return 0;
2011         /*
2012          * Set the outbound netlbl.
2013          */
2014         return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2015 }
2016
2017 /**
2018  * smack_socket_connect - connect access check
2019  * @sock: the socket
2020  * @sap: the other end
2021  * @addrlen: size of sap
2022  *
2023  * Verifies that a connection may be possible
2024  *
2025  * Returns 0 on success, and error code otherwise
2026  */
2027 static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
2028                                 int addrlen)
2029 {
2030         if (sock->sk == NULL || sock->sk->sk_family != PF_INET)
2031                 return 0;
2032         if (addrlen < sizeof(struct sockaddr_in))
2033                 return -EINVAL;
2034
2035         return smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap);
2036 }
2037
2038 /**
2039  * smack_flags_to_may - convert S_ to MAY_ values
2040  * @flags: the S_ value
2041  *
2042  * Returns the equivalent MAY_ value
2043  */
2044 static int smack_flags_to_may(int flags)
2045 {
2046         int may = 0;
2047
2048         if (flags & S_IRUGO)
2049                 may |= MAY_READ;
2050         if (flags & S_IWUGO)
2051                 may |= MAY_WRITE;
2052         if (flags & S_IXUGO)
2053                 may |= MAY_EXEC;
2054
2055         return may;
2056 }
2057
2058 /**
2059  * smack_msg_msg_alloc_security - Set the security blob for msg_msg
2060  * @msg: the object
2061  *
2062  * Returns 0
2063  */
2064 static int smack_msg_msg_alloc_security(struct msg_msg *msg)
2065 {
2066         msg->security = smk_of_current();
2067         return 0;
2068 }
2069
2070 /**
2071  * smack_msg_msg_free_security - Clear the security blob for msg_msg
2072  * @msg: the object
2073  *
2074  * Clears the blob pointer
2075  */
2076 static void smack_msg_msg_free_security(struct msg_msg *msg)
2077 {
2078         msg->security = NULL;
2079 }
2080
2081 /**
2082  * smack_of_shm - the smack pointer for the shm
2083  * @shp: the object
2084  *
2085  * Returns a pointer to the smack value
2086  */
2087 static char *smack_of_shm(struct shmid_kernel *shp)
2088 {
2089         return (char *)shp->shm_perm.security;
2090 }
2091
2092 /**
2093  * smack_shm_alloc_security - Set the security blob for shm
2094  * @shp: the object
2095  *
2096  * Returns 0
2097  */
2098 static int smack_shm_alloc_security(struct shmid_kernel *shp)
2099 {
2100         struct kern_ipc_perm *isp = &shp->shm_perm;
2101
2102         isp->security = smk_of_current();
2103         return 0;
2104 }
2105
2106 /**
2107  * smack_shm_free_security - Clear the security blob for shm
2108  * @shp: the object
2109  *
2110  * Clears the blob pointer
2111  */
2112 static void smack_shm_free_security(struct shmid_kernel *shp)
2113 {
2114         struct kern_ipc_perm *isp = &shp->shm_perm;
2115
2116         isp->security = NULL;
2117 }
2118
2119 /**
2120  * smk_curacc_shm : check if current has access on shm
2121  * @shp : the object
2122  * @access : access requested
2123  *
2124  * Returns 0 if current has the requested access, error code otherwise
2125  */
2126 static int smk_curacc_shm(struct shmid_kernel *shp, int access)
2127 {
2128         char *ssp = smack_of_shm(shp);
2129         struct smk_audit_info ad;
2130
2131 #ifdef CONFIG_AUDIT
2132         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2133         ad.a.u.ipc_id = shp->shm_perm.id;
2134 #endif
2135         return smk_curacc(ssp, access, &ad);
2136 }
2137
2138 /**
2139  * smack_shm_associate - Smack access check for shm
2140  * @shp: the object
2141  * @shmflg: access requested
2142  *
2143  * Returns 0 if current has the requested access, error code otherwise
2144  */
2145 static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
2146 {
2147         int may;
2148
2149         may = smack_flags_to_may(shmflg);
2150         return smk_curacc_shm(shp, may);
2151 }
2152
2153 /**
2154  * smack_shm_shmctl - Smack access check for shm
2155  * @shp: the object
2156  * @cmd: what it wants to do
2157  *
2158  * Returns 0 if current has the requested access, error code otherwise
2159  */
2160 static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
2161 {
2162         int may;
2163
2164         switch (cmd) {
2165         case IPC_STAT:
2166         case SHM_STAT:
2167                 may = MAY_READ;
2168                 break;
2169         case IPC_SET:
2170         case SHM_LOCK:
2171         case SHM_UNLOCK:
2172         case IPC_RMID:
2173                 may = MAY_READWRITE;
2174                 break;
2175         case IPC_INFO:
2176         case SHM_INFO:
2177                 /*
2178                  * System level information.
2179                  */
2180                 return 0;
2181         default:
2182                 return -EINVAL;
2183         }
2184         return smk_curacc_shm(shp, may);
2185 }
2186
2187 /**
2188  * smack_shm_shmat - Smack access for shmat
2189  * @shp: the object
2190  * @shmaddr: unused
2191  * @shmflg: access requested
2192  *
2193  * Returns 0 if current has the requested access, error code otherwise
2194  */
2195 static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
2196                            int shmflg)
2197 {
2198         int may;
2199
2200         may = smack_flags_to_may(shmflg);
2201         return smk_curacc_shm(shp, may);
2202 }
2203
2204 /**
2205  * smack_of_sem - the smack pointer for the sem
2206  * @sma: the object
2207  *
2208  * Returns a pointer to the smack value
2209  */
2210 static char *smack_of_sem(struct sem_array *sma)
2211 {
2212         return (char *)sma->sem_perm.security;
2213 }
2214
2215 /**
2216  * smack_sem_alloc_security - Set the security blob for sem
2217  * @sma: the object
2218  *
2219  * Returns 0
2220  */
2221 static int smack_sem_alloc_security(struct sem_array *sma)
2222 {
2223         struct kern_ipc_perm *isp = &sma->sem_perm;
2224
2225         isp->security = smk_of_current();
2226         return 0;
2227 }
2228
2229 /**
2230  * smack_sem_free_security - Clear the security blob for sem
2231  * @sma: the object
2232  *
2233  * Clears the blob pointer
2234  */
2235 static void smack_sem_free_security(struct sem_array *sma)
2236 {
2237         struct kern_ipc_perm *isp = &sma->sem_perm;
2238
2239         isp->security = NULL;
2240 }
2241
2242 /**
2243  * smk_curacc_sem : check if current has access on sem
2244  * @sma : the object
2245  * @access : access requested
2246  *
2247  * Returns 0 if current has the requested access, error code otherwise
2248  */
2249 static int smk_curacc_sem(struct sem_array *sma, int access)
2250 {
2251         char *ssp = smack_of_sem(sma);
2252         struct smk_audit_info ad;
2253
2254 #ifdef CONFIG_AUDIT
2255         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2256         ad.a.u.ipc_id = sma->sem_perm.id;
2257 #endif
2258         return smk_curacc(ssp, access, &ad);
2259 }
2260
2261 /**
2262  * smack_sem_associate - Smack access check for sem
2263  * @sma: the object
2264  * @semflg: access requested
2265  *
2266  * Returns 0 if current has the requested access, error code otherwise
2267  */
2268 static int smack_sem_associate(struct sem_array *sma, int semflg)
2269 {
2270         int may;
2271
2272         may = smack_flags_to_may(semflg);
2273         return smk_curacc_sem(sma, may);
2274 }
2275
2276 /**
2277  * smack_sem_shmctl - Smack access check for sem
2278  * @sma: the object
2279  * @cmd: what it wants to do
2280  *
2281  * Returns 0 if current has the requested access, error code otherwise
2282  */
2283 static int smack_sem_semctl(struct sem_array *sma, int cmd)
2284 {
2285         int may;
2286
2287         switch (cmd) {
2288         case GETPID:
2289         case GETNCNT:
2290         case GETZCNT:
2291         case GETVAL:
2292         case GETALL:
2293         case IPC_STAT:
2294         case SEM_STAT:
2295                 may = MAY_READ;
2296                 break;
2297         case SETVAL:
2298         case SETALL:
2299         case IPC_RMID:
2300         case IPC_SET:
2301                 may = MAY_READWRITE;
2302                 break;
2303         case IPC_INFO:
2304         case SEM_INFO:
2305                 /*
2306                  * System level information
2307                  */
2308                 return 0;
2309         default:
2310                 return -EINVAL;
2311         }
2312
2313         return smk_curacc_sem(sma, may);
2314 }
2315
2316 /**
2317  * smack_sem_semop - Smack checks of semaphore operations
2318  * @sma: the object
2319  * @sops: unused
2320  * @nsops: unused
2321  * @alter: unused
2322  *
2323  * Treated as read and write in all cases.
2324  *
2325  * Returns 0 if access is allowed, error code otherwise
2326  */
2327 static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
2328                            unsigned nsops, int alter)
2329 {
2330         return smk_curacc_sem(sma, MAY_READWRITE);
2331 }
2332
2333 /**
2334  * smack_msg_alloc_security - Set the security blob for msg
2335  * @msq: the object
2336  *
2337  * Returns 0
2338  */
2339 static int smack_msg_queue_alloc_security(struct msg_queue *msq)
2340 {
2341         struct kern_ipc_perm *kisp = &msq->q_perm;
2342
2343         kisp->security = smk_of_current();
2344         return 0;
2345 }
2346
2347 /**
2348  * smack_msg_free_security - Clear the security blob for msg
2349  * @msq: the object
2350  *
2351  * Clears the blob pointer
2352  */
2353 static void smack_msg_queue_free_security(struct msg_queue *msq)
2354 {
2355         struct kern_ipc_perm *kisp = &msq->q_perm;
2356
2357         kisp->security = NULL;
2358 }
2359
2360 /**
2361  * smack_of_msq - the smack pointer for the msq
2362  * @msq: the object
2363  *
2364  * Returns a pointer to the smack value
2365  */
2366 static char *smack_of_msq(struct msg_queue *msq)
2367 {
2368         return (char *)msq->q_perm.security;
2369 }
2370
2371 /**
2372  * smk_curacc_msq : helper to check if current has access on msq
2373  * @msq : the msq
2374  * @access : access requested
2375  *
2376  * return 0 if current has access, error otherwise
2377  */
2378 static int smk_curacc_msq(struct msg_queue *msq, int access)
2379 {
2380         char *msp = smack_of_msq(msq);
2381         struct smk_audit_info ad;
2382
2383 #ifdef CONFIG_AUDIT
2384         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2385         ad.a.u.ipc_id = msq->q_perm.id;
2386 #endif
2387         return smk_curacc(msp, access, &ad);
2388 }
2389
2390 /**
2391  * smack_msg_queue_associate - Smack access check for msg_queue
2392  * @msq: the object
2393  * @msqflg: access requested
2394  *
2395  * Returns 0 if current has the requested access, error code otherwise
2396  */
2397 static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
2398 {
2399         int may;
2400
2401         may = smack_flags_to_may(msqflg);
2402         return smk_curacc_msq(msq, may);
2403 }
2404
2405 /**
2406  * smack_msg_queue_msgctl - Smack access check for msg_queue
2407  * @msq: the object
2408  * @cmd: what it wants to do
2409  *
2410  * Returns 0 if current has the requested access, error code otherwise
2411  */
2412 static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
2413 {
2414         int may;
2415
2416         switch (cmd) {
2417         case IPC_STAT:
2418         case MSG_STAT:
2419                 may = MAY_READ;
2420                 break;
2421         case IPC_SET:
2422         case IPC_RMID:
2423                 may = MAY_READWRITE;
2424                 break;
2425         case IPC_INFO:
2426         case MSG_INFO:
2427                 /*
2428                  * System level information
2429                  */
2430                 return 0;
2431         default:
2432                 return -EINVAL;
2433         }
2434
2435         return smk_curacc_msq(msq, may);
2436 }
2437
2438 /**
2439  * smack_msg_queue_msgsnd - Smack access check for msg_queue
2440  * @msq: the object
2441  * @msg: unused
2442  * @msqflg: access requested
2443  *
2444  * Returns 0 if current has the requested access, error code otherwise
2445  */
2446 static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
2447                                   int msqflg)
2448 {
2449         int may;
2450
2451         may = smack_flags_to_may(msqflg);
2452         return smk_curacc_msq(msq, may);
2453 }
2454
2455 /**
2456  * smack_msg_queue_msgsnd - Smack access check for msg_queue
2457  * @msq: the object
2458  * @msg: unused
2459  * @target: unused
2460  * @type: unused
2461  * @mode: unused
2462  *
2463  * Returns 0 if current has read and write access, error code otherwise
2464  */
2465 static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
2466                         struct task_struct *target, long type, int mode)
2467 {
2468         return smk_curacc_msq(msq, MAY_READWRITE);
2469 }
2470
2471 /**
2472  * smack_ipc_permission - Smack access for ipc_permission()
2473  * @ipp: the object permissions
2474  * @flag: access requested
2475  *
2476  * Returns 0 if current has read and write access, error code otherwise
2477  */
2478 static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
2479 {
2480         char *isp = ipp->security;
2481         int may = smack_flags_to_may(flag);
2482         struct smk_audit_info ad;
2483
2484 #ifdef CONFIG_AUDIT
2485         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2486         ad.a.u.ipc_id = ipp->id;
2487 #endif
2488         return smk_curacc(isp, may, &ad);
2489 }
2490
2491 /**
2492  * smack_ipc_getsecid - Extract smack security id
2493  * @ipp: the object permissions
2494  * @secid: where result will be saved
2495  */
2496 static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
2497 {
2498         char *smack = ipp->security;
2499
2500         *secid = smack_to_secid(smack);
2501 }
2502
2503 /**
2504  * smack_d_instantiate - Make sure the blob is correct on an inode
2505  * @opt_dentry: dentry where inode will be attached
2506  * @inode: the object
2507  *
2508  * Set the inode's security blob if it hasn't been done already.
2509  */
2510 static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
2511 {
2512         struct super_block *sbp;
2513         struct superblock_smack *sbsp;
2514         struct inode_smack *isp;
2515         char *csp = smk_of_current();
2516         char *fetched;
2517         char *final;
2518         char trattr[TRANS_TRUE_SIZE];
2519         int transflag = 0;
2520         struct dentry *dp;
2521
2522         if (inode == NULL)
2523                 return;
2524
2525         isp = inode->i_security;
2526
2527         mutex_lock(&isp->smk_lock);
2528         /*
2529          * If the inode is already instantiated
2530          * take the quick way out
2531          */
2532         if (isp->smk_flags & SMK_INODE_INSTANT)
2533                 goto unlockandout;
2534
2535         sbp = inode->i_sb;
2536         sbsp = sbp->s_security;
2537         /*
2538          * We're going to use the superblock default label
2539          * if there's no label on the file.
2540          */
2541         final = sbsp->smk_default;
2542
2543         /*
2544          * If this is the root inode the superblock
2545          * may be in the process of initialization.
2546          * If that is the case use the root value out
2547          * of the superblock.
2548          */
2549         if (opt_dentry->d_parent == opt_dentry) {
2550                 isp->smk_inode = sbsp->smk_root;
2551                 isp->smk_flags |= SMK_INODE_INSTANT;
2552                 goto unlockandout;
2553         }
2554
2555         /*
2556          * This is pretty hackish.
2557          * Casey says that we shouldn't have to do
2558          * file system specific code, but it does help
2559          * with keeping it simple.
2560          */
2561         switch (sbp->s_magic) {
2562         case SMACK_MAGIC:
2563                 /*
2564                  * Casey says that it's a little embarrassing
2565                  * that the smack file system doesn't do
2566                  * extended attributes.
2567                  */
2568                 final = smack_known_star.smk_known;
2569                 break;
2570         case PIPEFS_MAGIC:
2571                 /*
2572                  * Casey says pipes are easy (?)
2573                  */
2574                 final = smack_known_star.smk_known;
2575                 break;
2576         case DEVPTS_SUPER_MAGIC:
2577                 /*
2578                  * devpts seems content with the label of the task.
2579                  * Programs that change smack have to treat the
2580                  * pty with respect.
2581                  */
2582                 final = csp;
2583                 break;
2584         case SOCKFS_MAGIC:
2585                 /*
2586                  * Socket access is controlled by the socket
2587                  * structures associated with the task involved.
2588                  */
2589                 final = smack_known_star.smk_known;
2590                 break;
2591         case PROC_SUPER_MAGIC:
2592                 /*
2593                  * Casey says procfs appears not to care.
2594                  * The superblock default suffices.
2595                  */
2596                 break;
2597         case TMPFS_MAGIC:
2598                 /*
2599                  * Device labels should come from the filesystem,
2600                  * but watch out, because they're volitile,
2601                  * getting recreated on every reboot.
2602                  */
2603                 final = smack_known_star.smk_known;
2604                 /*
2605                  * No break.
2606                  *
2607                  * If a smack value has been set we want to use it,
2608                  * but since tmpfs isn't giving us the opportunity
2609                  * to set mount options simulate setting the
2610                  * superblock default.
2611                  */
2612         default:
2613                 /*
2614                  * This isn't an understood special case.
2615                  * Get the value from the xattr.
2616                  */
2617
2618                 /*
2619                  * UNIX domain sockets use lower level socket data.
2620                  */
2621                 if (S_ISSOCK(inode->i_mode)) {
2622                         final = smack_known_star.smk_known;
2623                         break;
2624                 }
2625                 /*
2626                  * No xattr support means, alas, no SMACK label.
2627                  * Use the aforeapplied default.
2628                  * It would be curious if the label of the task
2629                  * does not match that assigned.
2630                  */
2631                 if (inode->i_op->getxattr == NULL)
2632                         break;
2633                 /*
2634                  * Get the dentry for xattr.
2635                  */
2636                 dp = dget(opt_dentry);
2637                 fetched = smk_fetch(XATTR_NAME_SMACK, inode, dp);
2638                 if (fetched != NULL) {
2639                         final = fetched;
2640                         if (S_ISDIR(inode->i_mode)) {
2641                                 trattr[0] = '\0';
2642                                 inode->i_op->getxattr(dp,
2643                                         XATTR_NAME_SMACKTRANSMUTE,
2644                                         trattr, TRANS_TRUE_SIZE);
2645                                 if (strncmp(trattr, TRANS_TRUE,
2646                                             TRANS_TRUE_SIZE) == 0)
2647                                         transflag = SMK_INODE_TRANSMUTE;
2648                         }
2649                 }
2650                 isp->smk_task = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp);
2651                 isp->smk_mmap = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp);
2652
2653                 dput(dp);
2654                 break;
2655         }
2656
2657         if (final == NULL)
2658                 isp->smk_inode = csp;
2659         else
2660                 isp->smk_inode = final;
2661
2662         isp->smk_flags |= (SMK_INODE_INSTANT | transflag);
2663
2664 unlockandout:
2665         mutex_unlock(&isp->smk_lock);
2666         return;
2667 }
2668
2669 /**
2670  * smack_getprocattr - Smack process attribute access
2671  * @p: the object task
2672  * @name: the name of the attribute in /proc/.../attr
2673  * @value: where to put the result
2674  *
2675  * Places a copy of the task Smack into value
2676  *
2677  * Returns the length of the smack label or an error code
2678  */
2679 static int smack_getprocattr(struct task_struct *p, char *name, char **value)
2680 {
2681         char *cp;
2682         int slen;
2683
2684         if (strcmp(name, "current") != 0)
2685                 return -EINVAL;
2686
2687         cp = kstrdup(smk_of_task(task_security(p)), GFP_KERNEL);
2688         if (cp == NULL)
2689                 return -ENOMEM;
2690
2691         slen = strlen(cp);
2692         *value = cp;
2693         return slen;
2694 }
2695
2696 /**
2697  * smack_setprocattr - Smack process attribute setting
2698  * @p: the object task
2699  * @name: the name of the attribute in /proc/.../attr
2700  * @value: the value to set
2701  * @size: the size of the value
2702  *
2703  * Sets the Smack value of the task. Only setting self
2704  * is permitted and only with privilege
2705  *
2706  * Returns the length of the smack label or an error code
2707  */
2708 static int smack_setprocattr(struct task_struct *p, char *name,
2709                              void *value, size_t size)
2710 {
2711         int rc;
2712         struct task_smack *tsp;
2713         struct task_smack *oldtsp;
2714         struct cred *new;
2715         char *newsmack;
2716
2717         /*
2718          * Changing another process' Smack value is too dangerous
2719          * and supports no sane use case.
2720          */
2721         if (p != current)
2722                 return -EPERM;
2723
2724         if (!capable(CAP_MAC_ADMIN))
2725                 return -EPERM;
2726
2727         if (value == NULL || size == 0 || size >= SMK_LABELLEN)
2728                 return -EINVAL;
2729
2730         if (strcmp(name, "current") != 0)
2731                 return -EINVAL;
2732
2733         newsmack = smk_import(value, size);
2734         if (newsmack == NULL)
2735                 return -EINVAL;
2736
2737         /*
2738          * No process is ever allowed the web ("@") label.
2739          */
2740         if (newsmack == smack_known_web.smk_known)
2741                 return -EPERM;
2742
2743         oldtsp = p->cred->security;
2744         new = prepare_creds();
2745         if (new == NULL)
2746                 return -ENOMEM;
2747
2748         tsp = new_task_smack(newsmack, oldtsp->smk_forked, GFP_KERNEL);
2749         if (tsp == NULL) {
2750                 kfree(new);
2751                 return -ENOMEM;
2752         }
2753         rc = smk_copy_rules(&tsp->smk_rules, &oldtsp->smk_rules, GFP_KERNEL);
2754         if (rc != 0)
2755                 return rc;
2756
2757         new->security = tsp;
2758         commit_creds(new);
2759         return size;
2760 }
2761
2762 /**
2763  * smack_unix_stream_connect - Smack access on UDS
2764  * @sock: one sock
2765  * @other: the other sock
2766  * @newsk: unused
2767  *
2768  * Return 0 if a subject with the smack of sock could access
2769  * an object with the smack of other, otherwise an error code
2770  */
2771 static int smack_unix_stream_connect(struct sock *sock,
2772                                      struct sock *other, struct sock *newsk)
2773 {
2774         struct socket_smack *ssp = sock->sk_security;
2775         struct socket_smack *osp = other->sk_security;
2776         struct smk_audit_info ad;
2777         int rc = 0;
2778
2779         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
2780         smk_ad_setfield_u_net_sk(&ad, other);
2781
2782         if (!capable(CAP_MAC_OVERRIDE))
2783                 rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);
2784
2785         return rc;
2786 }
2787
2788 /**
2789  * smack_unix_may_send - Smack access on UDS
2790  * @sock: one socket
2791  * @other: the other socket
2792  *
2793  * Return 0 if a subject with the smack of sock could access
2794  * an object with the smack of other, otherwise an error code
2795  */
2796 static int smack_unix_may_send(struct socket *sock, struct socket *other)
2797 {
2798         struct socket_smack *ssp = sock->sk->sk_security;
2799         struct socket_smack *osp = other->sk->sk_security;
2800         struct smk_audit_info ad;
2801         int rc = 0;
2802
2803         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
2804         smk_ad_setfield_u_net_sk(&ad, other->sk);
2805
2806         if (!capable(CAP_MAC_OVERRIDE))
2807                 rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);
2808
2809         return rc;
2810 }
2811
2812 /**
2813  * smack_socket_sendmsg - Smack check based on destination host
2814  * @sock: the socket
2815  * @msg: the message
2816  * @size: the size of the message
2817  *
2818  * Return 0 if the current subject can write to the destination
2819  * host. This is only a question if the destination is a single
2820  * label host.
2821  */
2822 static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
2823                                 int size)
2824 {
2825         struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;
2826
2827         /*
2828          * Perfectly reasonable for this to be NULL
2829          */
2830         if (sip == NULL || sip->sin_family != AF_INET)
2831                 return 0;
2832
2833         return smack_netlabel_send(sock->sk, sip);
2834 }
2835
2836 /**
2837  * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat pair to smack
2838  * @sap: netlabel secattr
2839  * @ssp: socket security information
2840  *
2841  * Returns a pointer to a Smack label found on the label list.
2842  */
2843 static char *smack_from_secattr(struct netlbl_lsm_secattr *sap,
2844                                 struct socket_smack *ssp)
2845 {
2846         struct smack_known *skp;
2847         char smack[SMK_LABELLEN];
2848         char *sp;
2849         int pcat;
2850
2851         if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
2852                 /*
2853                  * Looks like a CIPSO packet.
2854                  * If there are flags but no level netlabel isn't
2855                  * behaving the way we expect it to.
2856                  *
2857                  * Get the categories, if any
2858                  * Without guidance regarding the smack value
2859                  * for the packet fall back on the network
2860                  * ambient value.
2861                  */
2862                 memset(smack, '\0', SMK_LABELLEN);
2863                 if ((sap->flags & NETLBL_SECATTR_MLS_CAT) != 0)
2864                         for (pcat = -1;;) {
2865                                 pcat = netlbl_secattr_catmap_walk(
2866                                         sap->attr.mls.cat, pcat + 1);
2867                                 if (pcat < 0)
2868                                         break;
2869                                 smack_catset_bit(pcat, smack);
2870                         }
2871                 /*
2872                  * If it is CIPSO using smack direct mapping
2873                  * we are already done. WeeHee.
2874                  */
2875                 if (sap->attr.mls.lvl == smack_cipso_direct) {
2876                         /*
2877                          * The label sent is usually on the label list.
2878                          *
2879                          * If it is not we may still want to allow the
2880                          * delivery.
2881                          *
2882                          * If the recipient is accepting all packets
2883                          * because it is using the star ("*") label
2884                          * for SMACK64IPIN provide the web ("@") label
2885                          * so that a directed response will succeed.
2886                          * This is not very correct from a MAC point
2887                          * of view, but gets around the problem that
2888                          * locking prevents adding the newly discovered
2889                          * label to the list.
2890                          * The case where the recipient is not using
2891                          * the star label should obviously fail.
2892                          * The easy way to do this is to provide the
2893                          * star label as the subject label.
2894                          */
2895                         skp = smk_find_entry(smack);
2896                         if (skp != NULL)
2897                                 return skp->smk_known;
2898                         if (ssp != NULL &&
2899                             ssp->smk_in == smack_known_star.smk_known)
2900                                 return smack_known_web.smk_known;
2901                         return smack_known_star.smk_known;
2902                 }
2903                 /*
2904                  * Look it up in the supplied table if it is not
2905                  * a direct mapping.
2906                  */
2907                 sp = smack_from_cipso(sap->attr.mls.lvl, smack);
2908                 if (sp != NULL)
2909                         return sp;
2910                 if (ssp != NULL && ssp->smk_in == smack_known_star.smk_known)
2911                         return smack_known_web.smk_known;
2912                 return smack_known_star.smk_known;
2913         }
2914         if ((sap->flags & NETLBL_SECATTR_SECID) != 0) {
2915                 /*
2916                  * Looks like a fallback, which gives us a secid.
2917                  */
2918                 sp = smack_from_secid(sap->attr.secid);
2919                 /*
2920                  * This has got to be a bug because it is
2921                  * impossible to specify a fallback without
2922                  * specifying the label, which will ensure
2923                  * it has a secid, and the only way to get a
2924                  * secid is from a fallback.
2925                  */
2926                 BUG_ON(sp == NULL);
2927                 return sp;
2928         }
2929         /*
2930          * Without guidance regarding the smack value
2931          * for the packet fall back on the network
2932          * ambient value.
2933          */
2934         return smack_net_ambient;
2935 }
2936
2937 /**
2938  * smack_socket_sock_rcv_skb - Smack packet delivery access check
2939  * @sk: socket
2940  * @skb: packet
2941  *
2942  * Returns 0 if the packet should be delivered, an error code otherwise
2943  */
2944 static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
2945 {
2946         struct netlbl_lsm_secattr secattr;
2947         struct socket_smack *ssp = sk->sk_security;
2948         char *csp;
2949         int rc;
2950         struct smk_audit_info ad;
2951         if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2952                 return 0;
2953
2954         /*
2955          * Translate what netlabel gave us.
2956          */
2957         netlbl_secattr_init(&secattr);
2958
2959         rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
2960         if (rc == 0)
2961                 csp = smack_from_secattr(&secattr, ssp);
2962         else
2963                 csp = smack_net_ambient;
2964
2965         netlbl_secattr_destroy(&secattr);
2966
2967 #ifdef CONFIG_AUDIT
2968         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
2969         ad.a.u.net.family = sk->sk_family;
2970         ad.a.u.net.netif = skb->skb_iif;
2971         ipv4_skb_to_auditdata(skb, &ad.a, NULL);
2972 #endif
2973         /*
2974          * Receiving a packet requires that the other end
2975          * be able to write here. Read access is not required.
2976          * This is the simplist possible security model
2977          * for networking.
2978          */
2979         rc = smk_access(csp, ssp->smk_in, MAY_WRITE, &ad);
2980         if (rc != 0)
2981                 netlbl_skbuff_err(skb, rc, 0);
2982         return rc;
2983 }
2984
2985 /**
2986  * smack_socket_getpeersec_stream - pull in packet label
2987  * @sock: the socket
2988  * @optval: user's destination
2989  * @optlen: size thereof
2990  * @len: max thereof
2991  *
2992  * returns zero on success, an error code otherwise
2993  */
2994 static int smack_socket_getpeersec_stream(struct socket *sock,
2995                                           char __user *optval,
2996                                           int __user *optlen, unsigned len)
2997 {
2998         struct socket_smack *ssp;
2999         char *rcp = "";
3000         int slen = 1;
3001         int rc = 0;
3002
3003         ssp = sock->sk->sk_security;
3004         if (ssp->smk_packet != NULL) {
3005                 rcp = ssp->smk_packet;
3006                 slen = strlen(rcp) + 1;
3007         }
3008
3009         if (slen > len)
3010                 rc = -ERANGE;
3011         else if (copy_to_user(optval, rcp, slen) != 0)
3012                 rc = -EFAULT;
3013
3014         if (put_user(slen, optlen) != 0)
3015                 rc = -EFAULT;
3016
3017         return rc;
3018 }
3019
3020
3021 /**
3022  * smack_socket_getpeersec_dgram - pull in packet label
3023  * @sock: the peer socket
3024  * @skb: packet data
3025  * @secid: pointer to where to put the secid of the packet
3026  *
3027  * Sets the netlabel socket state on sk from parent
3028  */
3029 static int smack_socket_getpeersec_dgram(struct socket *sock,
3030                                          struct sk_buff *skb, u32 *secid)
3031
3032 {
3033         struct netlbl_lsm_secattr secattr;
3034         struct socket_smack *ssp = NULL;
3035         char *sp;
3036         int family = PF_UNSPEC;
3037         u32 s = 0;      /* 0 is the invalid secid */
3038         int rc;
3039
3040         if (skb != NULL) {
3041                 if (skb->protocol == htons(ETH_P_IP))
3042                         family = PF_INET;
3043                 else if (skb->protocol == htons(ETH_P_IPV6))
3044                         family = PF_INET6;
3045         }
3046         if (family == PF_UNSPEC && sock != NULL)
3047                 family = sock->sk->sk_family;
3048
3049         if (family == PF_UNIX) {
3050                 ssp = sock->sk->sk_security;
3051                 s = smack_to_secid(ssp->smk_out);
3052         } else if (family == PF_INET || family == PF_INET6) {
3053                 /*
3054                  * Translate what netlabel gave us.
3055                  */
3056                 if (sock != NULL && sock->sk != NULL)
3057                         ssp = sock->sk->sk_security;
3058                 netlbl_secattr_init(&secattr);
3059                 rc = netlbl_skbuff_getattr(skb, family, &secattr);
3060                 if (rc == 0) {
3061                         sp = smack_from_secattr(&secattr, ssp);
3062                         s = smack_to_secid(sp);
3063                 }
3064                 netlbl_secattr_destroy(&secattr);
3065         }
3066         *secid = s;
3067         if (s == 0)
3068                 return -EINVAL;
3069         return 0;
3070 }
3071
3072 /**
3073  * smack_sock_graft - Initialize a newly created socket with an existing sock
3074  * @sk: child sock
3075  * @parent: parent socket
3076  *
3077  * Set the smk_{in,out} state of an existing sock based on the process that
3078  * is creating the new socket.
3079  */
3080 static void smack_sock_graft(struct sock *sk, struct socket *parent)
3081 {
3082         struct socket_smack *ssp;
3083
3084         if (sk == NULL ||
3085             (sk->sk_family != PF_INET && sk->sk_family != PF_INET6))
3086                 return;
3087
3088         ssp = sk->sk_security;
3089         ssp->smk_in = ssp->smk_out = smk_of_current();
3090         /* cssp->smk_packet is already set in smack_inet_csk_clone() */
3091 }
3092
3093 /**
3094  * smack_inet_conn_request - Smack access check on connect
3095  * @sk: socket involved
3096  * @skb: packet
3097  * @req: unused
3098  *
3099  * Returns 0 if a task with the packet label could write to
3100  * the socket, otherwise an error code
3101  */
3102 static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
3103                                    struct request_sock *req)
3104 {
3105         u16 family = sk->sk_family;
3106         struct socket_smack *ssp = sk->sk_security;
3107         struct netlbl_lsm_secattr secattr;
3108         struct sockaddr_in addr;
3109         struct iphdr *hdr;
3110         char *sp;
3111         int rc;
3112         struct smk_audit_info ad;
3113
3114         /* handle mapped IPv4 packets arriving via IPv6 sockets */
3115         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
3116                 family = PF_INET;
3117
3118         netlbl_secattr_init(&secattr);
3119         rc = netlbl_skbuff_getattr(skb, family, &secattr);
3120         if (rc == 0)
3121                 sp = smack_from_secattr(&secattr, ssp);
3122         else
3123                 sp = smack_known_huh.smk_known;
3124         netlbl_secattr_destroy(&secattr);
3125
3126 #ifdef CONFIG_AUDIT
3127         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
3128         ad.a.u.net.family = family;
3129         ad.a.u.net.netif = skb->skb_iif;
3130         ipv4_skb_to_auditdata(skb, &ad.a, NULL);
3131 #endif
3132         /*
3133          * Receiving a packet requires that the other end be able to write
3134          * here. Read access is not required.
3135          */
3136         rc = smk_access(sp, ssp->smk_in, MAY_WRITE, &ad);
3137         if (rc != 0)
3138                 return rc;
3139
3140         /*
3141          * Save the peer's label in the request_sock so we can later setup
3142          * smk_packet in the child socket so that SO_PEERCRED can report it.
3143          */
3144         req->peer_secid = smack_to_secid(sp);
3145
3146         /*
3147          * We need to decide if we want to label the incoming connection here
3148          * if we do we only need to label the request_sock and the stack will
3149          * propagate the wire-label to the sock when it is created.
3150          */
3151         hdr = ip_hdr(skb);
3152         addr.sin_addr.s_addr = hdr->saddr;
3153         rcu_read_lock();
3154         if (smack_host_label(&addr) == NULL) {
3155                 rcu_read_unlock();
3156                 netlbl_secattr_init(&secattr);
3157                 smack_to_secattr(sp, &secattr);
3158                 rc = netlbl_req_setattr(req, &secattr);
3159                 netlbl_secattr_destroy(&secattr);
3160         } else {
3161                 rcu_read_unlock();
3162                 netlbl_req_delattr(req);
3163         }
3164
3165         return rc;
3166 }
3167
3168 /**
3169  * smack_inet_csk_clone - Copy the connection information to the new socket
3170  * @sk: the new socket
3171  * @req: the connection's request_sock
3172  *
3173  * Transfer the connection's peer label to the newly created socket.
3174  */
3175 static void smack_inet_csk_clone(struct sock *sk,
3176                                  const struct request_sock *req)
3177 {
3178         struct socket_smack *ssp = sk->sk_security;
3179
3180         if (req->peer_secid != 0)
3181                 ssp->smk_packet = smack_from_secid(req->peer_secid);
3182         else
3183                 ssp->smk_packet = NULL;
3184 }
3185
3186 /*
3187  * Key management security hooks
3188  *
3189  * Casey has not tested key support very heavily.
3190  * The permission check is most likely too restrictive.
3191  * If you care about keys please have a look.
3192  */
3193 #ifdef CONFIG_KEYS
3194
3195 /**
3196  * smack_key_alloc - Set the key security blob
3197  * @key: object
3198  * @cred: the credentials to use
3199  * @flags: unused
3200  *
3201  * No allocation required
3202  *
3203  * Returns 0
3204  */
3205 static int smack_key_alloc(struct key *key, const struct cred *cred,
3206                            unsigned long flags)
3207 {
3208         key->security = smk_of_task(cred->security);
3209         return 0;
3210 }
3211
3212 /**
3213  * smack_key_free - Clear the key security blob
3214  * @key: the object
3215  *
3216  * Clear the blob pointer
3217  */
3218 static void smack_key_free(struct key *key)
3219 {
3220         key->security = NULL;
3221 }
3222
3223 /*
3224  * smack_key_permission - Smack access on a key
3225  * @key_ref: gets to the object
3226  * @cred: the credentials to use
3227  * @perm: unused
3228  *
3229  * Return 0 if the task has read and write to the object,
3230  * an error code otherwise
3231  */
3232 static int smack_key_permission(key_ref_t key_ref,
3233                                 const struct cred *cred, key_perm_t perm)
3234 {
3235         struct key *keyp;
3236         struct smk_audit_info ad;
3237         char *tsp = smk_of_task(cred->security);
3238
3239         keyp = key_ref_to_ptr(key_ref);
3240         if (keyp == NULL)
3241                 return -EINVAL;
3242         /*
3243          * If the key hasn't been initialized give it access so that
3244          * it may do so.
3245          */
3246         if (keyp->security == NULL)
3247                 return 0;
3248         /*
3249          * This should not occur
3250          */
3251         if (tsp == NULL)
3252                 return -EACCES;
3253 #ifdef CONFIG_AUDIT
3254         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY);
3255         ad.a.u.key_struct.key = keyp->serial;
3256         ad.a.u.key_struct.key_desc = keyp->description;
3257 #endif
3258         return smk_access(tsp, keyp->security,
3259                                  MAY_READWRITE, &ad);
3260 }
3261 #endif /* CONFIG_KEYS */
3262
3263 /*
3264  * Smack Audit hooks
3265  *
3266  * Audit requires a unique representation of each Smack specific
3267  * rule. This unique representation is used to distinguish the
3268  * object to be audited from remaining kernel objects and also
3269  * works as a glue between the audit hooks.
3270  *
3271  * Since repository entries are added but never deleted, we'll use
3272  * the smack_known label address related to the given audit rule as
3273  * the needed unique representation. This also better fits the smack
3274  * model where nearly everything is a label.
3275  */
3276 #ifdef CONFIG_AUDIT
3277
3278 /**
3279  * smack_audit_rule_init - Initialize a smack audit rule
3280  * @field: audit rule fields given from user-space (audit.h)
3281  * @op: required testing operator (=, !=, >, <, ...)
3282  * @rulestr: smack label to be audited
3283  * @vrule: pointer to save our own audit rule representation
3284  *
3285  * Prepare to audit cases where (@field @op @rulestr) is true.
3286  * The label to be audited is created if necessay.
3287  */
3288 static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
3289 {
3290         char **rule = (char **)vrule;
3291         *rule = NULL;
3292
3293         if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
3294                 return -EINVAL;
3295
3296         if (op != Audit_equal && op != Audit_not_equal)
3297                 return -EINVAL;
3298
3299         *rule = smk_import(rulestr, 0);
3300
3301         return 0;
3302 }
3303
3304 /**
3305  * smack_audit_rule_known - Distinguish Smack audit rules
3306  * @krule: rule of interest, in Audit kernel representation format
3307  *
3308  * This is used to filter Smack rules from remaining Audit ones.
3309  * If it's proved that this rule belongs to us, the
3310  * audit_rule_match hook will be called to do the final judgement.
3311  */
3312 static int smack_audit_rule_known(struct audit_krule *krule)
3313 {
3314         struct audit_field *f;
3315         int i;
3316
3317         for (i = 0; i < krule->field_count; i++) {
3318                 f = &krule->fields[i];
3319
3320                 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
3321                         return 1;
3322         }
3323
3324         return 0;
3325 }
3326
3327 /**
3328  * smack_audit_rule_match - Audit given object ?
3329  * @secid: security id for identifying the object to test
3330  * @field: audit rule flags given from user-space
3331  * @op: required testing operator
3332  * @vrule: smack internal rule presentation
3333  * @actx: audit context associated with the check
3334  *
3335  * The core Audit hook. It's used to take the decision of
3336  * whether to audit or not to audit a given object.
3337  */
3338 static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
3339                                   struct audit_context *actx)
3340 {
3341         char *smack;
3342         char *rule = vrule;
3343
3344         if (!rule) {
3345                 audit_log(actx, GFP_KERNEL, AUDIT_SELINUX_ERR,
3346                           "Smack: missing rule\n");
3347                 return -ENOENT;
3348         }
3349
3350         if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
3351                 return 0;
3352
3353         smack = smack_from_secid(secid);
3354
3355         /*
3356          * No need to do string comparisons. If a match occurs,
3357          * both pointers will point to the same smack_known
3358          * label.
3359          */
3360         if (op == Audit_equal)
3361                 return (rule == smack);
3362         if (op == Audit_not_equal)
3363                 return (rule != smack);
3364
3365         return 0;
3366 }
3367
3368 /**
3369  * smack_audit_rule_free - free smack rule representation
3370  * @vrule: rule to be freed.
3371  *
3372  * No memory was allocated.
3373  */
3374 static void smack_audit_rule_free(void *vrule)
3375 {
3376         /* No-op */
3377 }
3378
3379 #endif /* CONFIG_AUDIT */
3380
3381 /**
3382  * smack_secid_to_secctx - return the smack label for a secid
3383  * @secid: incoming integer
3384  * @secdata: destination
3385  * @seclen: how long it is
3386  *
3387  * Exists for networking code.
3388  */
3389 static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
3390 {
3391         char *sp = smack_from_secid(secid);
3392
3393         if (secdata)
3394                 *secdata = sp;
3395         *seclen = strlen(sp);
3396         return 0;
3397 }
3398
3399 /**
3400  * smack_secctx_to_secid - return the secid for a smack label
3401  * @secdata: smack label
3402  * @seclen: how long result is
3403  * @secid: outgoing integer
3404  *
3405  * Exists for audit and networking code.
3406  */
3407 static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
3408 {
3409         *secid = smack_to_secid(secdata);
3410         return 0;
3411 }
3412
3413 /**
3414  * smack_release_secctx - don't do anything.
3415  * @secdata: unused
3416  * @seclen: unused
3417  *
3418  * Exists to make sure nothing gets done, and properly
3419  */
3420 static void smack_release_secctx(char *secdata, u32 seclen)
3421 {
3422 }
3423
3424 static int smack_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
3425 {
3426         return smack_inode_setsecurity(inode, XATTR_SMACK_SUFFIX, ctx, ctxlen, 0);
3427 }
3428
3429 static int smack_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
3430 {
3431         return __vfs_setxattr_noperm(dentry, XATTR_NAME_SMACK, ctx, ctxlen, 0);
3432 }
3433
3434 static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
3435 {
3436         int len = 0;
3437         len = smack_inode_getsecurity(inode, XATTR_SMACK_SUFFIX, ctx, true);
3438
3439         if (len < 0)
3440                 return len;
3441         *ctxlen = len;
3442         return 0;
3443 }
3444
3445 struct security_operations smack_ops = {
3446         .name =                         "smack",
3447
3448         .ptrace_access_check =          smack_ptrace_access_check,
3449         .ptrace_traceme =               smack_ptrace_traceme,
3450         .syslog =                       smack_syslog,
3451
3452         .sb_alloc_security =            smack_sb_alloc_security,
3453         .sb_free_security =             smack_sb_free_security,
3454         .sb_copy_data =                 smack_sb_copy_data,
3455         .sb_kern_mount =                smack_sb_kern_mount,
3456         .sb_statfs =                    smack_sb_statfs,
3457         .sb_mount =                     smack_sb_mount,
3458         .sb_umount =                    smack_sb_umount,
3459
3460         .bprm_set_creds =               smack_bprm_set_creds,
3461
3462         .inode_alloc_security =         smack_inode_alloc_security,
3463         .inode_free_security =          smack_inode_free_security,
3464         .inode_init_security =          smack_inode_init_security,
3465         .inode_link =                   smack_inode_link,
3466         .inode_unlink =                 smack_inode_unlink,
3467         .inode_rmdir =                  smack_inode_rmdir,
3468         .inode_rename =                 smack_inode_rename,
3469         .inode_permission =             smack_inode_permission,
3470         .inode_setattr =                smack_inode_setattr,
3471         .inode_getattr =                smack_inode_getattr,
3472         .inode_setxattr =               smack_inode_setxattr,
3473         .inode_post_setxattr =          smack_inode_post_setxattr,
3474         .inode_getxattr =               smack_inode_getxattr,
3475         .inode_removexattr =            smack_inode_removexattr,
3476         .inode_getsecurity =            smack_inode_getsecurity,
3477         .inode_setsecurity =            smack_inode_setsecurity,
3478         .inode_listsecurity =           smack_inode_listsecurity,
3479         .inode_getsecid =               smack_inode_getsecid,
3480
3481         .file_permission =              smack_file_permission,
3482         .file_alloc_security =          smack_file_alloc_security,
3483         .file_free_security =           smack_file_free_security,
3484         .file_ioctl =                   smack_file_ioctl,
3485         .file_lock =                    smack_file_lock,
3486         .file_fcntl =                   smack_file_fcntl,
3487         .file_mmap =                    smack_file_mmap,
3488         .file_set_fowner =              smack_file_set_fowner,
3489         .file_send_sigiotask =          smack_file_send_sigiotask,
3490         .file_receive =                 smack_file_receive,
3491
3492         .dentry_open =                  smack_dentry_open,
3493
3494         .cred_alloc_blank =             smack_cred_alloc_blank,
3495         .cred_free =                    smack_cred_free,
3496         .cred_prepare =                 smack_cred_prepare,
3497         .cred_transfer =                smack_cred_transfer,
3498         .kernel_act_as =                smack_kernel_act_as,
3499         .kernel_create_files_as =       smack_kernel_create_files_as,
3500         .task_setpgid =                 smack_task_setpgid,
3501         .task_getpgid =                 smack_task_getpgid,
3502         .task_getsid =                  smack_task_getsid,
3503         .task_getsecid =                smack_task_getsecid,
3504         .task_setnice =                 smack_task_setnice,
3505         .task_setioprio =               smack_task_setioprio,
3506         .task_getioprio =               smack_task_getioprio,
3507         .task_setscheduler =            smack_task_setscheduler,
3508         .task_getscheduler =            smack_task_getscheduler,
3509         .task_movememory =              smack_task_movememory,
3510         .task_kill =                    smack_task_kill,
3511         .task_wait =                    smack_task_wait,
3512         .task_to_inode =                smack_task_to_inode,
3513
3514         .ipc_permission =               smack_ipc_permission,
3515         .ipc_getsecid =                 smack_ipc_getsecid,
3516
3517         .msg_msg_alloc_security =       smack_msg_msg_alloc_security,
3518         .msg_msg_free_security =        smack_msg_msg_free_security,
3519
3520         .msg_queue_alloc_security =     smack_msg_queue_alloc_security,
3521         .msg_queue_free_security =      smack_msg_queue_free_security,
3522         .msg_queue_associate =          smack_msg_queue_associate,
3523         .msg_queue_msgctl =             smack_msg_queue_msgctl,
3524         .msg_queue_msgsnd =             smack_msg_queue_msgsnd,
3525         .msg_queue_msgrcv =             smack_msg_queue_msgrcv,
3526
3527         .shm_alloc_security =           smack_shm_alloc_security,
3528         .shm_free_security =            smack_shm_free_security,
3529         .shm_associate =                smack_shm_associate,
3530         .shm_shmctl =                   smack_shm_shmctl,
3531         .shm_shmat =                    smack_shm_shmat,
3532
3533         .sem_alloc_security =           smack_sem_alloc_security,
3534         .sem_free_security =            smack_sem_free_security,
3535         .sem_associate =                smack_sem_associate,
3536         .sem_semctl =                   smack_sem_semctl,
3537         .sem_semop =                    smack_sem_semop,
3538
3539         .d_instantiate =                smack_d_instantiate,
3540
3541         .getprocattr =                  smack_getprocattr,
3542         .setprocattr =                  smack_setprocattr,
3543
3544         .unix_stream_connect =          smack_unix_stream_connect,
3545         .unix_may_send =                smack_unix_may_send,
3546
3547         .socket_post_create =           smack_socket_post_create,
3548         .socket_connect =               smack_socket_connect,
3549         .socket_sendmsg =               smack_socket_sendmsg,
3550         .socket_sock_rcv_skb =          smack_socket_sock_rcv_skb,
3551         .socket_getpeersec_stream =     smack_socket_getpeersec_stream,
3552         .socket_getpeersec_dgram =      smack_socket_getpeersec_dgram,
3553         .sk_alloc_security =            smack_sk_alloc_security,
3554         .sk_free_security =             smack_sk_free_security,
3555         .sock_graft =                   smack_sock_graft,
3556         .inet_conn_request =            smack_inet_conn_request,
3557         .inet_csk_clone =               smack_inet_csk_clone,
3558
3559  /* key management security hooks */
3560 #ifdef CONFIG_KEYS
3561         .key_alloc =                    smack_key_alloc,
3562         .key_free =                     smack_key_free,
3563         .key_permission =               smack_key_permission,
3564 #endif /* CONFIG_KEYS */
3565
3566  /* Audit hooks */
3567 #ifdef CONFIG_AUDIT
3568         .audit_rule_init =              smack_audit_rule_init,
3569         .audit_rule_known =             smack_audit_rule_known,
3570         .audit_rule_match =             smack_audit_rule_match,
3571         .audit_rule_free =              smack_audit_rule_free,
3572 #endif /* CONFIG_AUDIT */
3573
3574         .secid_to_secctx =              smack_secid_to_secctx,
3575         .secctx_to_secid =              smack_secctx_to_secid,
3576         .release_secctx =               smack_release_secctx,
3577         .inode_notifysecctx =           smack_inode_notifysecctx,
3578         .inode_setsecctx =              smack_inode_setsecctx,
3579         .inode_getsecctx =              smack_inode_getsecctx,
3580 };
3581
3582
3583 static __init void init_smack_know_list(void)
3584 {
3585         list_add(&smack_known_huh.list, &smack_known_list);
3586         list_add(&smack_known_hat.list, &smack_known_list);
3587         list_add(&smack_known_star.list, &smack_known_list);
3588         list_add(&smack_known_floor.list, &smack_known_list);
3589         list_add(&smack_known_invalid.list, &smack_known_list);
3590         list_add(&smack_known_web.list, &smack_known_list);
3591 }
3592
3593 /**
3594  * smack_init - initialize the smack system
3595  *
3596  * Returns 0
3597  */
3598 static __init int smack_init(void)
3599 {
3600         struct cred *cred;
3601         struct task_smack *tsp;
3602
3603         if (!security_module_enable(&smack_ops))
3604                 return 0;
3605
3606         tsp = new_task_smack(smack_known_floor.smk_known,
3607                                 smack_known_floor.smk_known, GFP_KERNEL);
3608         if (tsp == NULL)
3609                 return -ENOMEM;
3610
3611         printk(KERN_INFO "Smack:  Initializing.\n");
3612
3613         /*
3614          * Set the security state for the initial task.
3615          */
3616         cred = (struct cred *) current->cred;
3617         cred->security = tsp;
3618
3619         /* initialize the smack_know_list */
3620         init_smack_know_list();
3621         /*
3622          * Initialize locks
3623          */
3624         spin_lock_init(&smack_known_huh.smk_cipsolock);
3625         spin_lock_init(&smack_known_hat.smk_cipsolock);
3626         spin_lock_init(&smack_known_star.smk_cipsolock);
3627         spin_lock_init(&smack_known_floor.smk_cipsolock);
3628         spin_lock_init(&smack_known_invalid.smk_cipsolock);
3629
3630         /*
3631          * Register with LSM
3632          */
3633         if (register_security(&smack_ops))
3634                 panic("smack: Unable to register with kernel.\n");
3635
3636         return 0;
3637 }
3638
3639 /*
3640  * Smack requires early initialization in order to label
3641  * all processes and objects when they are created.
3642  */
3643 security_initcall(smack_init);