d479def4d6a0088de7c99a76f1d6e15481ad5069
[muen/linux.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 <jarkko.sakkinen@intel.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  *  Copyright (C) 2011 Intel Corporation.
15  *
16  *      This program is free software; you can redistribute it and/or modify
17  *      it under the terms of the GNU General Public License version 2,
18  *      as published by the Free Software Foundation.
19  */
20
21 #include <linux/xattr.h>
22 #include <linux/pagemap.h>
23 #include <linux/mount.h>
24 #include <linux/stat.h>
25 #include <linux/kd.h>
26 #include <asm/ioctls.h>
27 #include <linux/ip.h>
28 #include <linux/tcp.h>
29 #include <linux/udp.h>
30 #include <linux/dccp.h>
31 #include <linux/icmpv6.h>
32 #include <linux/slab.h>
33 #include <linux/mutex.h>
34 #include <linux/pipe_fs_i.h>
35 #include <net/cipso_ipv4.h>
36 #include <net/ip.h>
37 #include <net/ipv6.h>
38 #include <linux/audit.h>
39 #include <linux/magic.h>
40 #include <linux/dcache.h>
41 #include <linux/personality.h>
42 #include <linux/msg.h>
43 #include <linux/shm.h>
44 #include <linux/binfmts.h>
45 #include <linux/parser.h>
46 #include "smack.h"
47
48 #define TRANS_TRUE      "TRUE"
49 #define TRANS_TRUE_SIZE 4
50
51 #define SMK_CONNECTING  0
52 #define SMK_RECEIVING   1
53 #define SMK_SENDING     2
54
55 #ifdef SMACK_IPV6_PORT_LABELING
56 DEFINE_MUTEX(smack_ipv6_lock);
57 static LIST_HEAD(smk_ipv6_port_list);
58 #endif
59 static struct kmem_cache *smack_inode_cache;
60 int smack_enabled;
61
62 #define A(s) {"smack"#s, sizeof("smack"#s) - 1, Opt_##s}
63 static struct {
64         const char *name;
65         int len;
66         int opt;
67 } smk_mount_opts[] = {
68         A(fsdefault), A(fsfloor), A(fshat), A(fsroot), A(fstransmute)
69 };
70 #undef A
71
72 static int match_opt_prefix(char *s, int l, char **arg)
73 {
74         int i;
75
76         for (i = 0; i < ARRAY_SIZE(smk_mount_opts); i++) {
77                 size_t len = smk_mount_opts[i].len;
78                 if (len > l || memcmp(s, smk_mount_opts[i].name, len))
79                         continue;
80                 if (len == l || s[len] != '=')
81                         continue;
82                 *arg = s + len + 1;
83                 return smk_mount_opts[i].opt;
84         }
85         return Opt_error;
86 }
87
88 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
89 static char *smk_bu_mess[] = {
90         "Bringup Error",        /* Unused */
91         "Bringup",              /* SMACK_BRINGUP_ALLOW */
92         "Unconfined Subject",   /* SMACK_UNCONFINED_SUBJECT */
93         "Unconfined Object",    /* SMACK_UNCONFINED_OBJECT */
94 };
95
96 static void smk_bu_mode(int mode, char *s)
97 {
98         int i = 0;
99
100         if (mode & MAY_READ)
101                 s[i++] = 'r';
102         if (mode & MAY_WRITE)
103                 s[i++] = 'w';
104         if (mode & MAY_EXEC)
105                 s[i++] = 'x';
106         if (mode & MAY_APPEND)
107                 s[i++] = 'a';
108         if (mode & MAY_TRANSMUTE)
109                 s[i++] = 't';
110         if (mode & MAY_LOCK)
111                 s[i++] = 'l';
112         if (i == 0)
113                 s[i++] = '-';
114         s[i] = '\0';
115 }
116 #endif
117
118 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
119 static int smk_bu_note(char *note, struct smack_known *sskp,
120                        struct smack_known *oskp, int mode, int rc)
121 {
122         char acc[SMK_NUM_ACCESS_TYPE + 1];
123
124         if (rc <= 0)
125                 return rc;
126         if (rc > SMACK_UNCONFINED_OBJECT)
127                 rc = 0;
128
129         smk_bu_mode(mode, acc);
130         pr_info("Smack %s: (%s %s %s) %s\n", smk_bu_mess[rc],
131                 sskp->smk_known, oskp->smk_known, acc, note);
132         return 0;
133 }
134 #else
135 #define smk_bu_note(note, sskp, oskp, mode, RC) (RC)
136 #endif
137
138 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
139 static int smk_bu_current(char *note, struct smack_known *oskp,
140                           int mode, int rc)
141 {
142         struct task_smack *tsp = current_security();
143         char acc[SMK_NUM_ACCESS_TYPE + 1];
144
145         if (rc <= 0)
146                 return rc;
147         if (rc > SMACK_UNCONFINED_OBJECT)
148                 rc = 0;
149
150         smk_bu_mode(mode, acc);
151         pr_info("Smack %s: (%s %s %s) %s %s\n", smk_bu_mess[rc],
152                 tsp->smk_task->smk_known, oskp->smk_known,
153                 acc, current->comm, note);
154         return 0;
155 }
156 #else
157 #define smk_bu_current(note, oskp, mode, RC) (RC)
158 #endif
159
160 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
161 static int smk_bu_task(struct task_struct *otp, int mode, int rc)
162 {
163         struct task_smack *tsp = current_security();
164         struct smack_known *smk_task = smk_of_task_struct(otp);
165         char acc[SMK_NUM_ACCESS_TYPE + 1];
166
167         if (rc <= 0)
168                 return rc;
169         if (rc > SMACK_UNCONFINED_OBJECT)
170                 rc = 0;
171
172         smk_bu_mode(mode, acc);
173         pr_info("Smack %s: (%s %s %s) %s to %s\n", smk_bu_mess[rc],
174                 tsp->smk_task->smk_known, smk_task->smk_known, acc,
175                 current->comm, otp->comm);
176         return 0;
177 }
178 #else
179 #define smk_bu_task(otp, mode, RC) (RC)
180 #endif
181
182 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
183 static int smk_bu_inode(struct inode *inode, int mode, int rc)
184 {
185         struct task_smack *tsp = current_security();
186         struct inode_smack *isp = inode->i_security;
187         char acc[SMK_NUM_ACCESS_TYPE + 1];
188
189         if (isp->smk_flags & SMK_INODE_IMPURE)
190                 pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
191                         inode->i_sb->s_id, inode->i_ino, current->comm);
192
193         if (rc <= 0)
194                 return rc;
195         if (rc > SMACK_UNCONFINED_OBJECT)
196                 rc = 0;
197         if (rc == SMACK_UNCONFINED_SUBJECT &&
198             (mode & (MAY_WRITE | MAY_APPEND)))
199                 isp->smk_flags |= SMK_INODE_IMPURE;
200
201         smk_bu_mode(mode, acc);
202
203         pr_info("Smack %s: (%s %s %s) inode=(%s %ld) %s\n", smk_bu_mess[rc],
204                 tsp->smk_task->smk_known, isp->smk_inode->smk_known, acc,
205                 inode->i_sb->s_id, inode->i_ino, current->comm);
206         return 0;
207 }
208 #else
209 #define smk_bu_inode(inode, mode, RC) (RC)
210 #endif
211
212 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
213 static int smk_bu_file(struct file *file, int mode, int rc)
214 {
215         struct task_smack *tsp = current_security();
216         struct smack_known *sskp = tsp->smk_task;
217         struct inode *inode = file_inode(file);
218         struct inode_smack *isp = inode->i_security;
219         char acc[SMK_NUM_ACCESS_TYPE + 1];
220
221         if (isp->smk_flags & SMK_INODE_IMPURE)
222                 pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
223                         inode->i_sb->s_id, inode->i_ino, current->comm);
224
225         if (rc <= 0)
226                 return rc;
227         if (rc > SMACK_UNCONFINED_OBJECT)
228                 rc = 0;
229
230         smk_bu_mode(mode, acc);
231         pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n", smk_bu_mess[rc],
232                 sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
233                 inode->i_sb->s_id, inode->i_ino, file,
234                 current->comm);
235         return 0;
236 }
237 #else
238 #define smk_bu_file(file, mode, RC) (RC)
239 #endif
240
241 #ifdef CONFIG_SECURITY_SMACK_BRINGUP
242 static int smk_bu_credfile(const struct cred *cred, struct file *file,
243                                 int mode, int rc)
244 {
245         struct task_smack *tsp = cred->security;
246         struct smack_known *sskp = tsp->smk_task;
247         struct inode *inode = file_inode(file);
248         struct inode_smack *isp = inode->i_security;
249         char acc[SMK_NUM_ACCESS_TYPE + 1];
250
251         if (isp->smk_flags & SMK_INODE_IMPURE)
252                 pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
253                         inode->i_sb->s_id, inode->i_ino, current->comm);
254
255         if (rc <= 0)
256                 return rc;
257         if (rc > SMACK_UNCONFINED_OBJECT)
258                 rc = 0;
259
260         smk_bu_mode(mode, acc);
261         pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n", smk_bu_mess[rc],
262                 sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
263                 inode->i_sb->s_id, inode->i_ino, file,
264                 current->comm);
265         return 0;
266 }
267 #else
268 #define smk_bu_credfile(cred, file, mode, RC) (RC)
269 #endif
270
271 /**
272  * smk_fetch - Fetch the smack label from a file.
273  * @name: type of the label (attribute)
274  * @ip: a pointer to the inode
275  * @dp: a pointer to the dentry
276  *
277  * Returns a pointer to the master list entry for the Smack label,
278  * NULL if there was no label to fetch, or an error code.
279  */
280 static struct smack_known *smk_fetch(const char *name, struct inode *ip,
281                                         struct dentry *dp)
282 {
283         int rc;
284         char *buffer;
285         struct smack_known *skp = NULL;
286
287         if (!(ip->i_opflags & IOP_XATTR))
288                 return ERR_PTR(-EOPNOTSUPP);
289
290         buffer = kzalloc(SMK_LONGLABEL, GFP_KERNEL);
291         if (buffer == NULL)
292                 return ERR_PTR(-ENOMEM);
293
294         rc = __vfs_getxattr(dp, ip, name, buffer, SMK_LONGLABEL);
295         if (rc < 0)
296                 skp = ERR_PTR(rc);
297         else if (rc == 0)
298                 skp = NULL;
299         else
300                 skp = smk_import_entry(buffer, rc);
301
302         kfree(buffer);
303
304         return skp;
305 }
306
307 /**
308  * new_inode_smack - allocate an inode security blob
309  * @skp: a pointer to the Smack label entry to use in the blob
310  *
311  * Returns the new blob or NULL if there's no memory available
312  */
313 static struct inode_smack *new_inode_smack(struct smack_known *skp)
314 {
315         struct inode_smack *isp;
316
317         isp = kmem_cache_zalloc(smack_inode_cache, GFP_NOFS);
318         if (isp == NULL)
319                 return NULL;
320
321         isp->smk_inode = skp;
322         isp->smk_flags = 0;
323         mutex_init(&isp->smk_lock);
324
325         return isp;
326 }
327
328 /**
329  * new_task_smack - allocate a task security blob
330  * @task: a pointer to the Smack label for the running task
331  * @forked: a pointer to the Smack label for the forked task
332  * @gfp: type of the memory for the allocation
333  *
334  * Returns the new blob or NULL if there's no memory available
335  */
336 static struct task_smack *new_task_smack(struct smack_known *task,
337                                         struct smack_known *forked, gfp_t gfp)
338 {
339         struct task_smack *tsp;
340
341         tsp = kzalloc(sizeof(struct task_smack), gfp);
342         if (tsp == NULL)
343                 return NULL;
344
345         tsp->smk_task = task;
346         tsp->smk_forked = forked;
347         INIT_LIST_HEAD(&tsp->smk_rules);
348         INIT_LIST_HEAD(&tsp->smk_relabel);
349         mutex_init(&tsp->smk_rules_lock);
350
351         return tsp;
352 }
353
354 /**
355  * smk_copy_rules - copy a rule set
356  * @nhead: new rules header pointer
357  * @ohead: old rules header pointer
358  * @gfp: type of the memory for the allocation
359  *
360  * Returns 0 on success, -ENOMEM on error
361  */
362 static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead,
363                                 gfp_t gfp)
364 {
365         struct smack_rule *nrp;
366         struct smack_rule *orp;
367         int rc = 0;
368
369         list_for_each_entry_rcu(orp, ohead, list) {
370                 nrp = kzalloc(sizeof(struct smack_rule), gfp);
371                 if (nrp == NULL) {
372                         rc = -ENOMEM;
373                         break;
374                 }
375                 *nrp = *orp;
376                 list_add_rcu(&nrp->list, nhead);
377         }
378         return rc;
379 }
380
381 /**
382  * smk_copy_relabel - copy smk_relabel labels list
383  * @nhead: new rules header pointer
384  * @ohead: old rules header pointer
385  * @gfp: type of the memory for the allocation
386  *
387  * Returns 0 on success, -ENOMEM on error
388  */
389 static int smk_copy_relabel(struct list_head *nhead, struct list_head *ohead,
390                                 gfp_t gfp)
391 {
392         struct smack_known_list_elem *nklep;
393         struct smack_known_list_elem *oklep;
394
395         list_for_each_entry(oklep, ohead, list) {
396                 nklep = kzalloc(sizeof(struct smack_known_list_elem), gfp);
397                 if (nklep == NULL) {
398                         smk_destroy_label_list(nhead);
399                         return -ENOMEM;
400                 }
401                 nklep->smk_label = oklep->smk_label;
402                 list_add(&nklep->list, nhead);
403         }
404
405         return 0;
406 }
407
408 /**
409  * smk_ptrace_mode - helper function for converting PTRACE_MODE_* into MAY_*
410  * @mode - input mode in form of PTRACE_MODE_*
411  *
412  * Returns a converted MAY_* mode usable by smack rules
413  */
414 static inline unsigned int smk_ptrace_mode(unsigned int mode)
415 {
416         if (mode & PTRACE_MODE_ATTACH)
417                 return MAY_READWRITE;
418         if (mode & PTRACE_MODE_READ)
419                 return MAY_READ;
420
421         return 0;
422 }
423
424 /**
425  * smk_ptrace_rule_check - helper for ptrace access
426  * @tracer: tracer process
427  * @tracee_known: label entry of the process that's about to be traced
428  * @mode: ptrace attachment mode (PTRACE_MODE_*)
429  * @func: name of the function that called us, used for audit
430  *
431  * Returns 0 on access granted, -error on error
432  */
433 static int smk_ptrace_rule_check(struct task_struct *tracer,
434                                  struct smack_known *tracee_known,
435                                  unsigned int mode, const char *func)
436 {
437         int rc;
438         struct smk_audit_info ad, *saip = NULL;
439         struct task_smack *tsp;
440         struct smack_known *tracer_known;
441         const struct cred *tracercred;
442
443         if ((mode & PTRACE_MODE_NOAUDIT) == 0) {
444                 smk_ad_init(&ad, func, LSM_AUDIT_DATA_TASK);
445                 smk_ad_setfield_u_tsk(&ad, tracer);
446                 saip = &ad;
447         }
448
449         rcu_read_lock();
450         tracercred = __task_cred(tracer);
451         tsp = tracercred->security;
452         tracer_known = smk_of_task(tsp);
453
454         if ((mode & PTRACE_MODE_ATTACH) &&
455             (smack_ptrace_rule == SMACK_PTRACE_EXACT ||
456              smack_ptrace_rule == SMACK_PTRACE_DRACONIAN)) {
457                 if (tracer_known->smk_known == tracee_known->smk_known)
458                         rc = 0;
459                 else if (smack_ptrace_rule == SMACK_PTRACE_DRACONIAN)
460                         rc = -EACCES;
461                 else if (smack_privileged_cred(CAP_SYS_PTRACE, tracercred))
462                         rc = 0;
463                 else
464                         rc = -EACCES;
465
466                 if (saip)
467                         smack_log(tracer_known->smk_known,
468                                   tracee_known->smk_known,
469                                   0, rc, saip);
470
471                 rcu_read_unlock();
472                 return rc;
473         }
474
475         /* In case of rule==SMACK_PTRACE_DEFAULT or mode==PTRACE_MODE_READ */
476         rc = smk_tskacc(tsp, tracee_known, smk_ptrace_mode(mode), saip);
477
478         rcu_read_unlock();
479         return rc;
480 }
481
482 /*
483  * LSM hooks.
484  * We he, that is fun!
485  */
486
487 /**
488  * smack_ptrace_access_check - Smack approval on PTRACE_ATTACH
489  * @ctp: child task pointer
490  * @mode: ptrace attachment mode (PTRACE_MODE_*)
491  *
492  * Returns 0 if access is OK, an error code otherwise
493  *
494  * Do the capability checks.
495  */
496 static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode)
497 {
498         struct smack_known *skp;
499
500         skp = smk_of_task_struct(ctp);
501
502         return smk_ptrace_rule_check(current, skp, mode, __func__);
503 }
504
505 /**
506  * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME
507  * @ptp: parent task pointer
508  *
509  * Returns 0 if access is OK, an error code otherwise
510  *
511  * Do the capability checks, and require PTRACE_MODE_ATTACH.
512  */
513 static int smack_ptrace_traceme(struct task_struct *ptp)
514 {
515         int rc;
516         struct smack_known *skp;
517
518         skp = smk_of_task(current_security());
519
520         rc = smk_ptrace_rule_check(ptp, skp, PTRACE_MODE_ATTACH, __func__);
521         return rc;
522 }
523
524 /**
525  * smack_syslog - Smack approval on syslog
526  * @type: message type
527  *
528  * Returns 0 on success, error code otherwise.
529  */
530 static int smack_syslog(int typefrom_file)
531 {
532         int rc = 0;
533         struct smack_known *skp = smk_of_current();
534
535         if (smack_privileged(CAP_MAC_OVERRIDE))
536                 return 0;
537
538         if (smack_syslog_label != NULL && smack_syslog_label != skp)
539                 rc = -EACCES;
540
541         return rc;
542 }
543
544
545 /*
546  * Superblock Hooks.
547  */
548
549 /**
550  * smack_sb_alloc_security - allocate a superblock blob
551  * @sb: the superblock getting the blob
552  *
553  * Returns 0 on success or -ENOMEM on error.
554  */
555 static int smack_sb_alloc_security(struct super_block *sb)
556 {
557         struct superblock_smack *sbsp;
558
559         sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
560
561         if (sbsp == NULL)
562                 return -ENOMEM;
563
564         sbsp->smk_root = &smack_known_floor;
565         sbsp->smk_default = &smack_known_floor;
566         sbsp->smk_floor = &smack_known_floor;
567         sbsp->smk_hat = &smack_known_hat;
568         /*
569          * SMK_SB_INITIALIZED will be zero from kzalloc.
570          */
571         sb->s_security = sbsp;
572
573         return 0;
574 }
575
576 /**
577  * smack_sb_free_security - free a superblock blob
578  * @sb: the superblock getting the blob
579  *
580  */
581 static void smack_sb_free_security(struct super_block *sb)
582 {
583         kfree(sb->s_security);
584         sb->s_security = NULL;
585 }
586
587 struct smack_mnt_opts {
588         const char *fsdefault, *fsfloor, *fshat, *fsroot, *fstransmute;
589 };
590
591 static void smack_free_mnt_opts(void *mnt_opts)
592 {
593         struct smack_mnt_opts *opts = mnt_opts;
594         kfree(opts->fsdefault);
595         kfree(opts->fsfloor);
596         kfree(opts->fshat);
597         kfree(opts->fsroot);
598         kfree(opts->fstransmute);
599         kfree(opts);
600 }
601
602 /**
603  * smack_sb_copy_data - copy mount options data for processing
604  * @orig: where to start
605  * @smackopts: mount options string
606  *
607  * Returns 0 on success or -ENOMEM on error.
608  *
609  * Copy the Smack specific mount options out of the mount
610  * options list.
611  */
612 static int smack_sb_copy_data(char *orig, char *smackopts)
613 {
614         char *cp, *commap, *otheropts, *dp;
615
616         otheropts = (char *)get_zeroed_page(GFP_KERNEL);
617         if (otheropts == NULL)
618                 return -ENOMEM;
619
620         for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
621                 if (strstr(cp, SMK_FSDEFAULT) == cp)
622                         dp = smackopts;
623                 else if (strstr(cp, SMK_FSFLOOR) == cp)
624                         dp = smackopts;
625                 else if (strstr(cp, SMK_FSHAT) == cp)
626                         dp = smackopts;
627                 else if (strstr(cp, SMK_FSROOT) == cp)
628                         dp = smackopts;
629                 else if (strstr(cp, SMK_FSTRANS) == cp)
630                         dp = smackopts;
631                 else
632                         dp = otheropts;
633
634                 commap = strchr(cp, ',');
635                 if (commap != NULL)
636                         *commap = '\0';
637
638                 if (*dp != '\0')
639                         strcat(dp, ",");
640                 strcat(dp, cp);
641         }
642
643         strcpy(orig, otheropts);
644         free_page((unsigned long)otheropts);
645
646         return 0;
647 }
648
649 static int smack_add_opt(int token, const char *s, void **mnt_opts)
650 {
651         struct smack_mnt_opts *opts = *mnt_opts;
652
653         if (!opts) {
654                 opts = kzalloc(sizeof(struct smack_mnt_opts), GFP_KERNEL);
655                 if (!opts)
656                         return -ENOMEM;
657                 *mnt_opts = opts;
658         }
659
660         if (!s)
661                 return -ENOMEM;
662
663         switch (token) {
664         case Opt_fsdefault:
665                 if (opts->fsdefault)
666                         goto out_opt_err;
667                 opts->fsdefault = s;
668                 break;
669         case Opt_fsfloor:
670                 if (opts->fsfloor)
671                         goto out_opt_err;
672                 opts->fsfloor = s;
673                 break;
674         case Opt_fshat:
675                 if (opts->fshat)
676                         goto out_opt_err;
677                 opts->fshat = s;
678                 break;
679         case Opt_fsroot:
680                 if (opts->fsroot)
681                         goto out_opt_err;
682                 opts->fsroot = s;
683                 break;
684         case Opt_fstransmute:
685                 if (opts->fstransmute)
686                         goto out_opt_err;
687                 opts->fstransmute = s;
688                 break;
689         }
690         return 0;
691
692 out_opt_err:
693         pr_warn("Smack: duplicate mount options\n");
694         return -EINVAL;
695 }
696
697 /**
698  * smack_parse_opts_str - parse Smack specific mount options
699  * @options: mount options string
700  * @opts: where to store converted mount opts
701  *
702  * Returns 0 on success or -ENOMEM on error.
703  *
704  * converts Smack specific mount options to generic security option format
705  */
706 static int smack_parse_opts_str(char *options,
707                 void **mnt_opts)
708 {
709         char *from = options;
710
711         if (!options)
712                 return 0;
713
714         while (1) {
715                 char *next = strchr(from, ',');
716                 int token, len, rc;
717                 char *arg = NULL;
718
719                 if (next)
720                         len = next - from;
721                 else
722                         len = strlen(from);
723
724                 token = match_opt_prefix(from, len, &arg);
725                 arg = kmemdup_nul(arg, from + len - arg, GFP_KERNEL);
726                 rc = smack_add_opt(token, arg, mnt_opts);
727                 if (unlikely(rc)) {
728                         kfree(arg);
729                         if (*mnt_opts)
730                                 smack_free_mnt_opts(*mnt_opts);
731                         *mnt_opts = NULL;
732                         return rc;
733                 }
734                 if (!from[len])
735                         break;
736                 from += len + 1;
737         }
738         return 0;
739 }
740
741 static int smack_sb_eat_lsm_opts(char *options, void **mnt_opts)
742 {
743         char *s = (char *)get_zeroed_page(GFP_KERNEL);
744         int err;
745
746         if (!s)
747                 return -ENOMEM;
748         err = smack_sb_copy_data(options, s);
749         if (!err)
750                 err = smack_parse_opts_str(s, mnt_opts);
751         free_page((unsigned long)s);
752         return err;
753 }
754
755 /**
756  * smack_set_mnt_opts - set Smack specific mount options
757  * @sb: the file system superblock
758  * @opts: Smack mount options
759  * @kern_flags: mount option from kernel space or user space
760  * @set_kern_flags: where to store converted mount opts
761  *
762  * Returns 0 on success, an error code on failure
763  *
764  * Allow filesystems with binary mount data to explicitly set Smack mount
765  * labels.
766  */
767 static int smack_set_mnt_opts(struct super_block *sb,
768                 void *mnt_opts,
769                 unsigned long kern_flags,
770                 unsigned long *set_kern_flags)
771 {
772         struct dentry *root = sb->s_root;
773         struct inode *inode = d_backing_inode(root);
774         struct superblock_smack *sp = sb->s_security;
775         struct inode_smack *isp;
776         struct smack_known *skp;
777         struct smack_mnt_opts *opts = mnt_opts;
778         bool transmute = false;
779
780         if (sp->smk_flags & SMK_SB_INITIALIZED)
781                 return 0;
782
783         if (!smack_privileged(CAP_MAC_ADMIN)) {
784                 /*
785                  * Unprivileged mounts don't get to specify Smack values.
786                  */
787                 if (opts)
788                         return -EPERM;
789                 /*
790                  * Unprivileged mounts get root and default from the caller.
791                  */
792                 skp = smk_of_current();
793                 sp->smk_root = skp;
794                 sp->smk_default = skp;
795                 /*
796                  * For a handful of fs types with no user-controlled
797                  * backing store it's okay to trust security labels
798                  * in the filesystem. The rest are untrusted.
799                  */
800                 if (sb->s_user_ns != &init_user_ns &&
801                     sb->s_magic != SYSFS_MAGIC && sb->s_magic != TMPFS_MAGIC &&
802                     sb->s_magic != RAMFS_MAGIC) {
803                         transmute = true;
804                         sp->smk_flags |= SMK_SB_UNTRUSTED;
805                 }
806         }
807
808         sp->smk_flags |= SMK_SB_INITIALIZED;
809
810         if (opts) {
811                 if (opts->fsdefault) {
812                         skp = smk_import_entry(opts->fsdefault, 0);
813                         if (IS_ERR(skp))
814                                 return PTR_ERR(skp);
815                         sp->smk_default = skp;
816                 }
817                 if (opts->fsfloor) {
818                         skp = smk_import_entry(opts->fsfloor, 0);
819                         if (IS_ERR(skp))
820                                 return PTR_ERR(skp);
821                         sp->smk_floor = skp;
822                 }
823                 if (opts->fshat) {
824                         skp = smk_import_entry(opts->fshat, 0);
825                         if (IS_ERR(skp))
826                                 return PTR_ERR(skp);
827                         sp->smk_hat = skp;
828                 }
829                 if (opts->fsroot) {
830                         skp = smk_import_entry(opts->fsroot, 0);
831                         if (IS_ERR(skp))
832                                 return PTR_ERR(skp);
833                         sp->smk_root = skp;
834                 }
835                 if (opts->fstransmute) {
836                         skp = smk_import_entry(opts->fstransmute, 0);
837                         if (IS_ERR(skp))
838                                 return PTR_ERR(skp);
839                         sp->smk_root = skp;
840                         transmute = true;
841                 }
842         }
843
844         /*
845          * Initialize the root inode.
846          */
847         isp = inode->i_security;
848         if (isp == NULL) {
849                 isp = new_inode_smack(sp->smk_root);
850                 if (isp == NULL)
851                         return -ENOMEM;
852                 inode->i_security = isp;
853         } else
854                 isp->smk_inode = sp->smk_root;
855
856         if (transmute)
857                 isp->smk_flags |= SMK_INODE_TRANSMUTE;
858
859         return 0;
860 }
861
862 /**
863  * smack_sb_statfs - Smack check on statfs
864  * @dentry: identifies the file system in question
865  *
866  * Returns 0 if current can read the floor of the filesystem,
867  * and error code otherwise
868  */
869 static int smack_sb_statfs(struct dentry *dentry)
870 {
871         struct superblock_smack *sbp = dentry->d_sb->s_security;
872         int rc;
873         struct smk_audit_info ad;
874
875         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
876         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
877
878         rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad);
879         rc = smk_bu_current("statfs", sbp->smk_floor, MAY_READ, rc);
880         return rc;
881 }
882
883 /*
884  * BPRM hooks
885  */
886
887 /**
888  * smack_bprm_set_creds - set creds for exec
889  * @bprm: the exec information
890  *
891  * Returns 0 if it gets a blob, -EPERM if exec forbidden and -ENOMEM otherwise
892  */
893 static int smack_bprm_set_creds(struct linux_binprm *bprm)
894 {
895         struct inode *inode = file_inode(bprm->file);
896         struct task_smack *bsp = bprm->cred->security;
897         struct inode_smack *isp;
898         struct superblock_smack *sbsp;
899         int rc;
900
901         if (bprm->called_set_creds)
902                 return 0;
903
904         isp = inode->i_security;
905         if (isp->smk_task == NULL || isp->smk_task == bsp->smk_task)
906                 return 0;
907
908         sbsp = inode->i_sb->s_security;
909         if ((sbsp->smk_flags & SMK_SB_UNTRUSTED) &&
910             isp->smk_task != sbsp->smk_root)
911                 return 0;
912
913         if (bprm->unsafe & LSM_UNSAFE_PTRACE) {
914                 struct task_struct *tracer;
915                 rc = 0;
916
917                 rcu_read_lock();
918                 tracer = ptrace_parent(current);
919                 if (likely(tracer != NULL))
920                         rc = smk_ptrace_rule_check(tracer,
921                                                    isp->smk_task,
922                                                    PTRACE_MODE_ATTACH,
923                                                    __func__);
924                 rcu_read_unlock();
925
926                 if (rc != 0)
927                         return rc;
928         } else if (bprm->unsafe)
929                 return -EPERM;
930
931         bsp->smk_task = isp->smk_task;
932         bprm->per_clear |= PER_CLEAR_ON_SETID;
933
934         /* Decide if this is a secure exec. */
935         if (bsp->smk_task != bsp->smk_forked)
936                 bprm->secureexec = 1;
937
938         return 0;
939 }
940
941 /*
942  * Inode hooks
943  */
944
945 /**
946  * smack_inode_alloc_security - allocate an inode blob
947  * @inode: the inode in need of a blob
948  *
949  * Returns 0 if it gets a blob, -ENOMEM otherwise
950  */
951 static int smack_inode_alloc_security(struct inode *inode)
952 {
953         struct smack_known *skp = smk_of_current();
954
955         inode->i_security = new_inode_smack(skp);
956         if (inode->i_security == NULL)
957                 return -ENOMEM;
958         return 0;
959 }
960
961 /**
962  * smack_inode_free_rcu - Free inode_smack blob from cache
963  * @head: the rcu_head for getting inode_smack pointer
964  *
965  *  Call back function called from call_rcu() to free
966  *  the i_security blob pointer in inode
967  */
968 static void smack_inode_free_rcu(struct rcu_head *head)
969 {
970         struct inode_smack *issp;
971
972         issp = container_of(head, struct inode_smack, smk_rcu);
973         kmem_cache_free(smack_inode_cache, issp);
974 }
975
976 /**
977  * smack_inode_free_security - free an inode blob using call_rcu()
978  * @inode: the inode with a blob
979  *
980  * Clears the blob pointer in inode using RCU
981  */
982 static void smack_inode_free_security(struct inode *inode)
983 {
984         struct inode_smack *issp = inode->i_security;
985
986         /*
987          * The inode may still be referenced in a path walk and
988          * a call to smack_inode_permission() can be made
989          * after smack_inode_free_security() is called.
990          * To avoid race condition free the i_security via RCU
991          * and leave the current inode->i_security pointer intact.
992          * The inode will be freed after the RCU grace period too.
993          */
994         call_rcu(&issp->smk_rcu, smack_inode_free_rcu);
995 }
996
997 /**
998  * smack_inode_init_security - copy out the smack from an inode
999  * @inode: the newly created inode
1000  * @dir: containing directory object
1001  * @qstr: unused
1002  * @name: where to put the attribute name
1003  * @value: where to put the attribute value
1004  * @len: where to put the length of the attribute
1005  *
1006  * Returns 0 if it all works out, -ENOMEM if there's no memory
1007  */
1008 static int smack_inode_init_security(struct inode *inode, struct inode *dir,
1009                                      const struct qstr *qstr, const char **name,
1010                                      void **value, size_t *len)
1011 {
1012         struct inode_smack *issp = inode->i_security;
1013         struct smack_known *skp = smk_of_current();
1014         struct smack_known *isp = smk_of_inode(inode);
1015         struct smack_known *dsp = smk_of_inode(dir);
1016         int may;
1017
1018         if (name)
1019                 *name = XATTR_SMACK_SUFFIX;
1020
1021         if (value && len) {
1022                 rcu_read_lock();
1023                 may = smk_access_entry(skp->smk_known, dsp->smk_known,
1024                                        &skp->smk_rules);
1025                 rcu_read_unlock();
1026
1027                 /*
1028                  * If the access rule allows transmutation and
1029                  * the directory requests transmutation then
1030                  * by all means transmute.
1031                  * Mark the inode as changed.
1032                  */
1033                 if (may > 0 && ((may & MAY_TRANSMUTE) != 0) &&
1034                     smk_inode_transmutable(dir)) {
1035                         isp = dsp;
1036                         issp->smk_flags |= SMK_INODE_CHANGED;
1037                 }
1038
1039                 *value = kstrdup(isp->smk_known, GFP_NOFS);
1040                 if (*value == NULL)
1041                         return -ENOMEM;
1042
1043                 *len = strlen(isp->smk_known);
1044         }
1045
1046         return 0;
1047 }
1048
1049 /**
1050  * smack_inode_link - Smack check on link
1051  * @old_dentry: the existing object
1052  * @dir: unused
1053  * @new_dentry: the new object
1054  *
1055  * Returns 0 if access is permitted, an error code otherwise
1056  */
1057 static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
1058                             struct dentry *new_dentry)
1059 {
1060         struct smack_known *isp;
1061         struct smk_audit_info ad;
1062         int rc;
1063
1064         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1065         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
1066
1067         isp = smk_of_inode(d_backing_inode(old_dentry));
1068         rc = smk_curacc(isp, MAY_WRITE, &ad);
1069         rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_WRITE, rc);
1070
1071         if (rc == 0 && d_is_positive(new_dentry)) {
1072                 isp = smk_of_inode(d_backing_inode(new_dentry));
1073                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
1074                 rc = smk_curacc(isp, MAY_WRITE, &ad);
1075                 rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_WRITE, rc);
1076         }
1077
1078         return rc;
1079 }
1080
1081 /**
1082  * smack_inode_unlink - Smack check on inode deletion
1083  * @dir: containing directory object
1084  * @dentry: file to unlink
1085  *
1086  * Returns 0 if current can write the containing directory
1087  * and the object, error code otherwise
1088  */
1089 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
1090 {
1091         struct inode *ip = d_backing_inode(dentry);
1092         struct smk_audit_info ad;
1093         int rc;
1094
1095         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1096         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
1097
1098         /*
1099          * You need write access to the thing you're unlinking
1100          */
1101         rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad);
1102         rc = smk_bu_inode(ip, MAY_WRITE, rc);
1103         if (rc == 0) {
1104                 /*
1105                  * You also need write access to the containing directory
1106                  */
1107                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
1108                 smk_ad_setfield_u_fs_inode(&ad, dir);
1109                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
1110                 rc = smk_bu_inode(dir, MAY_WRITE, rc);
1111         }
1112         return rc;
1113 }
1114
1115 /**
1116  * smack_inode_rmdir - Smack check on directory deletion
1117  * @dir: containing directory object
1118  * @dentry: directory to unlink
1119  *
1120  * Returns 0 if current can write the containing directory
1121  * and the directory, error code otherwise
1122  */
1123 static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
1124 {
1125         struct smk_audit_info ad;
1126         int rc;
1127
1128         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1129         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
1130
1131         /*
1132          * You need write access to the thing you're removing
1133          */
1134         rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
1135         rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
1136         if (rc == 0) {
1137                 /*
1138                  * You also need write access to the containing directory
1139                  */
1140                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
1141                 smk_ad_setfield_u_fs_inode(&ad, dir);
1142                 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
1143                 rc = smk_bu_inode(dir, MAY_WRITE, rc);
1144         }
1145
1146         return rc;
1147 }
1148
1149 /**
1150  * smack_inode_rename - Smack check on rename
1151  * @old_inode: unused
1152  * @old_dentry: the old object
1153  * @new_inode: unused
1154  * @new_dentry: the new object
1155  *
1156  * Read and write access is required on both the old and
1157  * new directories.
1158  *
1159  * Returns 0 if access is permitted, an error code otherwise
1160  */
1161 static int smack_inode_rename(struct inode *old_inode,
1162                               struct dentry *old_dentry,
1163                               struct inode *new_inode,
1164                               struct dentry *new_dentry)
1165 {
1166         int rc;
1167         struct smack_known *isp;
1168         struct smk_audit_info ad;
1169
1170         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1171         smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
1172
1173         isp = smk_of_inode(d_backing_inode(old_dentry));
1174         rc = smk_curacc(isp, MAY_READWRITE, &ad);
1175         rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_READWRITE, rc);
1176
1177         if (rc == 0 && d_is_positive(new_dentry)) {
1178                 isp = smk_of_inode(d_backing_inode(new_dentry));
1179                 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
1180                 rc = smk_curacc(isp, MAY_READWRITE, &ad);
1181                 rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_READWRITE, rc);
1182         }
1183         return rc;
1184 }
1185
1186 /**
1187  * smack_inode_permission - Smack version of permission()
1188  * @inode: the inode in question
1189  * @mask: the access requested
1190  *
1191  * This is the important Smack hook.
1192  *
1193  * Returns 0 if access is permitted, -EACCES otherwise
1194  */
1195 static int smack_inode_permission(struct inode *inode, int mask)
1196 {
1197         struct superblock_smack *sbsp = inode->i_sb->s_security;
1198         struct smk_audit_info ad;
1199         int no_block = mask & MAY_NOT_BLOCK;
1200         int rc;
1201
1202         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
1203         /*
1204          * No permission to check. Existence test. Yup, it's there.
1205          */
1206         if (mask == 0)
1207                 return 0;
1208
1209         if (sbsp->smk_flags & SMK_SB_UNTRUSTED) {
1210                 if (smk_of_inode(inode) != sbsp->smk_root)
1211                         return -EACCES;
1212         }
1213
1214         /* May be droppable after audit */
1215         if (no_block)
1216                 return -ECHILD;
1217         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
1218         smk_ad_setfield_u_fs_inode(&ad, inode);
1219         rc = smk_curacc(smk_of_inode(inode), mask, &ad);
1220         rc = smk_bu_inode(inode, mask, rc);
1221         return rc;
1222 }
1223
1224 /**
1225  * smack_inode_setattr - Smack check for setting attributes
1226  * @dentry: the object
1227  * @iattr: for the force flag
1228  *
1229  * Returns 0 if access is permitted, an error code otherwise
1230  */
1231 static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
1232 {
1233         struct smk_audit_info ad;
1234         int rc;
1235
1236         /*
1237          * Need to allow for clearing the setuid bit.
1238          */
1239         if (iattr->ia_valid & ATTR_FORCE)
1240                 return 0;
1241         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1242         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
1243
1244         rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
1245         rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
1246         return rc;
1247 }
1248
1249 /**
1250  * smack_inode_getattr - Smack check for getting attributes
1251  * @mnt: vfsmount of the object
1252  * @dentry: the object
1253  *
1254  * Returns 0 if access is permitted, an error code otherwise
1255  */
1256 static int smack_inode_getattr(const struct path *path)
1257 {
1258         struct smk_audit_info ad;
1259         struct inode *inode = d_backing_inode(path->dentry);
1260         int rc;
1261
1262         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1263         smk_ad_setfield_u_fs_path(&ad, *path);
1264         rc = smk_curacc(smk_of_inode(inode), MAY_READ, &ad);
1265         rc = smk_bu_inode(inode, MAY_READ, rc);
1266         return rc;
1267 }
1268
1269 /**
1270  * smack_inode_setxattr - Smack check for setting xattrs
1271  * @dentry: the object
1272  * @name: name of the attribute
1273  * @value: value of the attribute
1274  * @size: size of the value
1275  * @flags: unused
1276  *
1277  * This protects the Smack attribute explicitly.
1278  *
1279  * Returns 0 if access is permitted, an error code otherwise
1280  */
1281 static int smack_inode_setxattr(struct dentry *dentry, const char *name,
1282                                 const void *value, size_t size, int flags)
1283 {
1284         struct smk_audit_info ad;
1285         struct smack_known *skp;
1286         int check_priv = 0;
1287         int check_import = 0;
1288         int check_star = 0;
1289         int rc = 0;
1290
1291         /*
1292          * Check label validity here so import won't fail in post_setxattr
1293          */
1294         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
1295             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
1296             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0) {
1297                 check_priv = 1;
1298                 check_import = 1;
1299         } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
1300                    strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
1301                 check_priv = 1;
1302                 check_import = 1;
1303                 check_star = 1;
1304         } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
1305                 check_priv = 1;
1306                 if (size != TRANS_TRUE_SIZE ||
1307                     strncmp(value, TRANS_TRUE, TRANS_TRUE_SIZE) != 0)
1308                         rc = -EINVAL;
1309         } else
1310                 rc = cap_inode_setxattr(dentry, name, value, size, flags);
1311
1312         if (check_priv && !smack_privileged(CAP_MAC_ADMIN))
1313                 rc = -EPERM;
1314
1315         if (rc == 0 && check_import) {
1316                 skp = size ? smk_import_entry(value, size) : NULL;
1317                 if (IS_ERR(skp))
1318                         rc = PTR_ERR(skp);
1319                 else if (skp == NULL || (check_star &&
1320                     (skp == &smack_known_star || skp == &smack_known_web)))
1321                         rc = -EINVAL;
1322         }
1323
1324         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1325         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
1326
1327         if (rc == 0) {
1328                 rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
1329                 rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
1330         }
1331
1332         return rc;
1333 }
1334
1335 /**
1336  * smack_inode_post_setxattr - Apply the Smack update approved above
1337  * @dentry: object
1338  * @name: attribute name
1339  * @value: attribute value
1340  * @size: attribute size
1341  * @flags: unused
1342  *
1343  * Set the pointer in the inode blob to the entry found
1344  * in the master label list.
1345  */
1346 static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
1347                                       const void *value, size_t size, int flags)
1348 {
1349         struct smack_known *skp;
1350         struct inode_smack *isp = d_backing_inode(dentry)->i_security;
1351
1352         if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
1353                 isp->smk_flags |= SMK_INODE_TRANSMUTE;
1354                 return;
1355         }
1356
1357         if (strcmp(name, XATTR_NAME_SMACK) == 0) {
1358                 skp = smk_import_entry(value, size);
1359                 if (!IS_ERR(skp))
1360                         isp->smk_inode = skp;
1361         } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0) {
1362                 skp = smk_import_entry(value, size);
1363                 if (!IS_ERR(skp))
1364                         isp->smk_task = skp;
1365         } else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
1366                 skp = smk_import_entry(value, size);
1367                 if (!IS_ERR(skp))
1368                         isp->smk_mmap = skp;
1369         }
1370
1371         return;
1372 }
1373
1374 /**
1375  * smack_inode_getxattr - Smack check on getxattr
1376  * @dentry: the object
1377  * @name: unused
1378  *
1379  * Returns 0 if access is permitted, an error code otherwise
1380  */
1381 static int smack_inode_getxattr(struct dentry *dentry, const char *name)
1382 {
1383         struct smk_audit_info ad;
1384         int rc;
1385
1386         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1387         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
1388
1389         rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_READ, &ad);
1390         rc = smk_bu_inode(d_backing_inode(dentry), MAY_READ, rc);
1391         return rc;
1392 }
1393
1394 /**
1395  * smack_inode_removexattr - Smack check on removexattr
1396  * @dentry: the object
1397  * @name: name of the attribute
1398  *
1399  * Removing the Smack attribute requires CAP_MAC_ADMIN
1400  *
1401  * Returns 0 if access is permitted, an error code otherwise
1402  */
1403 static int smack_inode_removexattr(struct dentry *dentry, const char *name)
1404 {
1405         struct inode_smack *isp;
1406         struct smk_audit_info ad;
1407         int rc = 0;
1408
1409         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
1410             strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
1411             strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
1412             strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
1413             strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 ||
1414             strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
1415                 if (!smack_privileged(CAP_MAC_ADMIN))
1416                         rc = -EPERM;
1417         } else
1418                 rc = cap_inode_removexattr(dentry, name);
1419
1420         if (rc != 0)
1421                 return rc;
1422
1423         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
1424         smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
1425
1426         rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad);
1427         rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc);
1428         if (rc != 0)
1429                 return rc;
1430
1431         isp = d_backing_inode(dentry)->i_security;
1432         /*
1433          * Don't do anything special for these.
1434          *      XATTR_NAME_SMACKIPIN
1435          *      XATTR_NAME_SMACKIPOUT
1436          */
1437         if (strcmp(name, XATTR_NAME_SMACK) == 0) {
1438                 struct super_block *sbp = dentry->d_sb;
1439                 struct superblock_smack *sbsp = sbp->s_security;
1440
1441                 isp->smk_inode = sbsp->smk_default;
1442         } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0)
1443                 isp->smk_task = NULL;
1444         else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0)
1445                 isp->smk_mmap = NULL;
1446         else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0)
1447                 isp->smk_flags &= ~SMK_INODE_TRANSMUTE;
1448
1449         return 0;
1450 }
1451
1452 /**
1453  * smack_inode_getsecurity - get smack xattrs
1454  * @inode: the object
1455  * @name: attribute name
1456  * @buffer: where to put the result
1457  * @alloc: duplicate memory
1458  *
1459  * Returns the size of the attribute or an error code
1460  */
1461 static int smack_inode_getsecurity(struct inode *inode,
1462                                    const char *name, void **buffer,
1463                                    bool alloc)
1464 {
1465         struct socket_smack *ssp;
1466         struct socket *sock;
1467         struct super_block *sbp;
1468         struct inode *ip = (struct inode *)inode;
1469         struct smack_known *isp;
1470
1471         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0)
1472                 isp = smk_of_inode(inode);
1473         else {
1474                 /*
1475                  * The rest of the Smack xattrs are only on sockets.
1476                  */
1477                 sbp = ip->i_sb;
1478                 if (sbp->s_magic != SOCKFS_MAGIC)
1479                         return -EOPNOTSUPP;
1480
1481                 sock = SOCKET_I(ip);
1482                 if (sock == NULL || sock->sk == NULL)
1483                         return -EOPNOTSUPP;
1484
1485                 ssp = sock->sk->sk_security;
1486
1487                 if (strcmp(name, XATTR_SMACK_IPIN) == 0)
1488                         isp = ssp->smk_in;
1489                 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
1490                         isp = ssp->smk_out;
1491                 else
1492                         return -EOPNOTSUPP;
1493         }
1494
1495         if (alloc) {
1496                 *buffer = kstrdup(isp->smk_known, GFP_KERNEL);
1497                 if (*buffer == NULL)
1498                         return -ENOMEM;
1499         }
1500
1501         return strlen(isp->smk_known);
1502 }
1503
1504
1505 /**
1506  * smack_inode_listsecurity - list the Smack attributes
1507  * @inode: the object
1508  * @buffer: where they go
1509  * @buffer_size: size of buffer
1510  */
1511 static int smack_inode_listsecurity(struct inode *inode, char *buffer,
1512                                     size_t buffer_size)
1513 {
1514         int len = sizeof(XATTR_NAME_SMACK);
1515
1516         if (buffer != NULL && len <= buffer_size)
1517                 memcpy(buffer, XATTR_NAME_SMACK, len);
1518
1519         return len;
1520 }
1521
1522 /**
1523  * smack_inode_getsecid - Extract inode's security id
1524  * @inode: inode to extract the info from
1525  * @secid: where result will be saved
1526  */
1527 static void smack_inode_getsecid(struct inode *inode, u32 *secid)
1528 {
1529         struct smack_known *skp = smk_of_inode(inode);
1530
1531         *secid = skp->smk_secid;
1532 }
1533
1534 /*
1535  * File Hooks
1536  */
1537
1538 /*
1539  * There is no smack_file_permission hook
1540  *
1541  * Should access checks be done on each read or write?
1542  * UNICOS and SELinux say yes.
1543  * Trusted Solaris, Trusted Irix, and just about everyone else says no.
1544  *
1545  * I'll say no for now. Smack does not do the frequent
1546  * label changing that SELinux does.
1547  */
1548
1549 /**
1550  * smack_file_alloc_security - assign a file security blob
1551  * @file: the object
1552  *
1553  * The security blob for a file is a pointer to the master
1554  * label list, so no allocation is done.
1555  *
1556  * f_security is the owner security information. It
1557  * isn't used on file access checks, it's for send_sigio.
1558  *
1559  * Returns 0
1560  */
1561 static int smack_file_alloc_security(struct file *file)
1562 {
1563         struct smack_known *skp = smk_of_current();
1564
1565         file->f_security = skp;
1566         return 0;
1567 }
1568
1569 /**
1570  * smack_file_free_security - clear a file security blob
1571  * @file: the object
1572  *
1573  * The security blob for a file is a pointer to the master
1574  * label list, so no memory is freed.
1575  */
1576 static void smack_file_free_security(struct file *file)
1577 {
1578         file->f_security = NULL;
1579 }
1580
1581 /**
1582  * smack_file_ioctl - Smack check on ioctls
1583  * @file: the object
1584  * @cmd: what to do
1585  * @arg: unused
1586  *
1587  * Relies heavily on the correct use of the ioctl command conventions.
1588  *
1589  * Returns 0 if allowed, error code otherwise
1590  */
1591 static int smack_file_ioctl(struct file *file, unsigned int cmd,
1592                             unsigned long arg)
1593 {
1594         int rc = 0;
1595         struct smk_audit_info ad;
1596         struct inode *inode = file_inode(file);
1597
1598         if (unlikely(IS_PRIVATE(inode)))
1599                 return 0;
1600
1601         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1602         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1603
1604         if (_IOC_DIR(cmd) & _IOC_WRITE) {
1605                 rc = smk_curacc(smk_of_inode(inode), MAY_WRITE, &ad);
1606                 rc = smk_bu_file(file, MAY_WRITE, rc);
1607         }
1608
1609         if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ)) {
1610                 rc = smk_curacc(smk_of_inode(inode), MAY_READ, &ad);
1611                 rc = smk_bu_file(file, MAY_READ, rc);
1612         }
1613
1614         return rc;
1615 }
1616
1617 /**
1618  * smack_file_lock - Smack check on file locking
1619  * @file: the object
1620  * @cmd: unused
1621  *
1622  * Returns 0 if current has lock access, error code otherwise
1623  */
1624 static int smack_file_lock(struct file *file, unsigned int cmd)
1625 {
1626         struct smk_audit_info ad;
1627         int rc;
1628         struct inode *inode = file_inode(file);
1629
1630         if (unlikely(IS_PRIVATE(inode)))
1631                 return 0;
1632
1633         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1634         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1635         rc = smk_curacc(smk_of_inode(inode), MAY_LOCK, &ad);
1636         rc = smk_bu_file(file, MAY_LOCK, rc);
1637         return rc;
1638 }
1639
1640 /**
1641  * smack_file_fcntl - Smack check on fcntl
1642  * @file: the object
1643  * @cmd: what action to check
1644  * @arg: unused
1645  *
1646  * Generally these operations are harmless.
1647  * File locking operations present an obvious mechanism
1648  * for passing information, so they require write access.
1649  *
1650  * Returns 0 if current has access, error code otherwise
1651  */
1652 static int smack_file_fcntl(struct file *file, unsigned int cmd,
1653                             unsigned long arg)
1654 {
1655         struct smk_audit_info ad;
1656         int rc = 0;
1657         struct inode *inode = file_inode(file);
1658
1659         if (unlikely(IS_PRIVATE(inode)))
1660                 return 0;
1661
1662         switch (cmd) {
1663         case F_GETLK:
1664                 break;
1665         case F_SETLK:
1666         case F_SETLKW:
1667                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1668                 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1669                 rc = smk_curacc(smk_of_inode(inode), MAY_LOCK, &ad);
1670                 rc = smk_bu_file(file, MAY_LOCK, rc);
1671                 break;
1672         case F_SETOWN:
1673         case F_SETSIG:
1674                 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1675                 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1676                 rc = smk_curacc(smk_of_inode(inode), MAY_WRITE, &ad);
1677                 rc = smk_bu_file(file, MAY_WRITE, rc);
1678                 break;
1679         default:
1680                 break;
1681         }
1682
1683         return rc;
1684 }
1685
1686 /**
1687  * smack_mmap_file :
1688  * Check permissions for a mmap operation.  The @file may be NULL, e.g.
1689  * if mapping anonymous memory.
1690  * @file contains the file structure for file to map (may be NULL).
1691  * @reqprot contains the protection requested by the application.
1692  * @prot contains the protection that will be applied by the kernel.
1693  * @flags contains the operational flags.
1694  * Return 0 if permission is granted.
1695  */
1696 static int smack_mmap_file(struct file *file,
1697                            unsigned long reqprot, unsigned long prot,
1698                            unsigned long flags)
1699 {
1700         struct smack_known *skp;
1701         struct smack_known *mkp;
1702         struct smack_rule *srp;
1703         struct task_smack *tsp;
1704         struct smack_known *okp;
1705         struct inode_smack *isp;
1706         struct superblock_smack *sbsp;
1707         int may;
1708         int mmay;
1709         int tmay;
1710         int rc;
1711
1712         if (file == NULL)
1713                 return 0;
1714
1715         if (unlikely(IS_PRIVATE(file_inode(file))))
1716                 return 0;
1717
1718         isp = file_inode(file)->i_security;
1719         if (isp->smk_mmap == NULL)
1720                 return 0;
1721         sbsp = file_inode(file)->i_sb->s_security;
1722         if (sbsp->smk_flags & SMK_SB_UNTRUSTED &&
1723             isp->smk_mmap != sbsp->smk_root)
1724                 return -EACCES;
1725         mkp = isp->smk_mmap;
1726
1727         tsp = current_security();
1728         skp = smk_of_current();
1729         rc = 0;
1730
1731         rcu_read_lock();
1732         /*
1733          * For each Smack rule associated with the subject
1734          * label verify that the SMACK64MMAP also has access
1735          * to that rule's object label.
1736          */
1737         list_for_each_entry_rcu(srp, &skp->smk_rules, list) {
1738                 okp = srp->smk_object;
1739                 /*
1740                  * Matching labels always allows access.
1741                  */
1742                 if (mkp->smk_known == okp->smk_known)
1743                         continue;
1744                 /*
1745                  * If there is a matching local rule take
1746                  * that into account as well.
1747                  */
1748                 may = smk_access_entry(srp->smk_subject->smk_known,
1749                                        okp->smk_known,
1750                                        &tsp->smk_rules);
1751                 if (may == -ENOENT)
1752                         may = srp->smk_access;
1753                 else
1754                         may &= srp->smk_access;
1755                 /*
1756                  * If may is zero the SMACK64MMAP subject can't
1757                  * possibly have less access.
1758                  */
1759                 if (may == 0)
1760                         continue;
1761
1762                 /*
1763                  * Fetch the global list entry.
1764                  * If there isn't one a SMACK64MMAP subject
1765                  * can't have as much access as current.
1766                  */
1767                 mmay = smk_access_entry(mkp->smk_known, okp->smk_known,
1768                                         &mkp->smk_rules);
1769                 if (mmay == -ENOENT) {
1770                         rc = -EACCES;
1771                         break;
1772                 }
1773                 /*
1774                  * If there is a local entry it modifies the
1775                  * potential access, too.
1776                  */
1777                 tmay = smk_access_entry(mkp->smk_known, okp->smk_known,
1778                                         &tsp->smk_rules);
1779                 if (tmay != -ENOENT)
1780                         mmay &= tmay;
1781
1782                 /*
1783                  * If there is any access available to current that is
1784                  * not available to a SMACK64MMAP subject
1785                  * deny access.
1786                  */
1787                 if ((may | mmay) != mmay) {
1788                         rc = -EACCES;
1789                         break;
1790                 }
1791         }
1792
1793         rcu_read_unlock();
1794
1795         return rc;
1796 }
1797
1798 /**
1799  * smack_file_set_fowner - set the file security blob value
1800  * @file: object in question
1801  *
1802  */
1803 static void smack_file_set_fowner(struct file *file)
1804 {
1805         file->f_security = smk_of_current();
1806 }
1807
1808 /**
1809  * smack_file_send_sigiotask - Smack on sigio
1810  * @tsk: The target task
1811  * @fown: the object the signal come from
1812  * @signum: unused
1813  *
1814  * Allow a privileged task to get signals even if it shouldn't
1815  *
1816  * Returns 0 if a subject with the object's smack could
1817  * write to the task, an error code otherwise.
1818  */
1819 static int smack_file_send_sigiotask(struct task_struct *tsk,
1820                                      struct fown_struct *fown, int signum)
1821 {
1822         struct smack_known *skp;
1823         struct smack_known *tkp = smk_of_task(tsk->cred->security);
1824         const struct cred *tcred;
1825         struct file *file;
1826         int rc;
1827         struct smk_audit_info ad;
1828
1829         /*
1830          * struct fown_struct is never outside the context of a struct file
1831          */
1832         file = container_of(fown, struct file, f_owner);
1833
1834         /* we don't log here as rc can be overriden */
1835         skp = file->f_security;
1836         rc = smk_access(skp, tkp, MAY_DELIVER, NULL);
1837         rc = smk_bu_note("sigiotask", skp, tkp, MAY_DELIVER, rc);
1838
1839         rcu_read_lock();
1840         tcred = __task_cred(tsk);
1841         if (rc != 0 && smack_privileged_cred(CAP_MAC_OVERRIDE, tcred))
1842                 rc = 0;
1843         rcu_read_unlock();
1844
1845         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1846         smk_ad_setfield_u_tsk(&ad, tsk);
1847         smack_log(skp->smk_known, tkp->smk_known, MAY_DELIVER, rc, &ad);
1848         return rc;
1849 }
1850
1851 /**
1852  * smack_file_receive - Smack file receive check
1853  * @file: the object
1854  *
1855  * Returns 0 if current has access, error code otherwise
1856  */
1857 static int smack_file_receive(struct file *file)
1858 {
1859         int rc;
1860         int may = 0;
1861         struct smk_audit_info ad;
1862         struct inode *inode = file_inode(file);
1863         struct socket *sock;
1864         struct task_smack *tsp;
1865         struct socket_smack *ssp;
1866
1867         if (unlikely(IS_PRIVATE(inode)))
1868                 return 0;
1869
1870         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1871         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1872
1873         if (inode->i_sb->s_magic == SOCKFS_MAGIC) {
1874                 sock = SOCKET_I(inode);
1875                 ssp = sock->sk->sk_security;
1876                 tsp = current_security();
1877                 /*
1878                  * If the receiving process can't write to the
1879                  * passed socket or if the passed socket can't
1880                  * write to the receiving process don't accept
1881                  * the passed socket.
1882                  */
1883                 rc = smk_access(tsp->smk_task, ssp->smk_out, MAY_WRITE, &ad);
1884                 rc = smk_bu_file(file, may, rc);
1885                 if (rc < 0)
1886                         return rc;
1887                 rc = smk_access(ssp->smk_in, tsp->smk_task, MAY_WRITE, &ad);
1888                 rc = smk_bu_file(file, may, rc);
1889                 return rc;
1890         }
1891         /*
1892          * This code relies on bitmasks.
1893          */
1894         if (file->f_mode & FMODE_READ)
1895                 may = MAY_READ;
1896         if (file->f_mode & FMODE_WRITE)
1897                 may |= MAY_WRITE;
1898
1899         rc = smk_curacc(smk_of_inode(inode), may, &ad);
1900         rc = smk_bu_file(file, may, rc);
1901         return rc;
1902 }
1903
1904 /**
1905  * smack_file_open - Smack dentry open processing
1906  * @file: the object
1907  * @cred: task credential
1908  *
1909  * Set the security blob in the file structure.
1910  * Allow the open only if the task has read access. There are
1911  * many read operations (e.g. fstat) that you can do with an
1912  * fd even if you have the file open write-only.
1913  *
1914  * Returns 0
1915  */
1916 static int smack_file_open(struct file *file)
1917 {
1918         struct task_smack *tsp = file->f_cred->security;
1919         struct inode *inode = file_inode(file);
1920         struct smk_audit_info ad;
1921         int rc;
1922
1923         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1924         smk_ad_setfield_u_fs_path(&ad, file->f_path);
1925         rc = smk_tskacc(tsp, smk_of_inode(inode), MAY_READ, &ad);
1926         rc = smk_bu_credfile(file->f_cred, file, MAY_READ, rc);
1927
1928         return rc;
1929 }
1930
1931 /*
1932  * Task hooks
1933  */
1934
1935 /**
1936  * smack_cred_alloc_blank - "allocate" blank task-level security credentials
1937  * @new: the new credentials
1938  * @gfp: the atomicity of any memory allocations
1939  *
1940  * Prepare a blank set of credentials for modification.  This must allocate all
1941  * the memory the LSM module might require such that cred_transfer() can
1942  * complete without error.
1943  */
1944 static int smack_cred_alloc_blank(struct cred *cred, gfp_t gfp)
1945 {
1946         struct task_smack *tsp;
1947
1948         tsp = new_task_smack(NULL, NULL, gfp);
1949         if (tsp == NULL)
1950                 return -ENOMEM;
1951
1952         cred->security = tsp;
1953
1954         return 0;
1955 }
1956
1957
1958 /**
1959  * smack_cred_free - "free" task-level security credentials
1960  * @cred: the credentials in question
1961  *
1962  */
1963 static void smack_cred_free(struct cred *cred)
1964 {
1965         struct task_smack *tsp = cred->security;
1966         struct smack_rule *rp;
1967         struct list_head *l;
1968         struct list_head *n;
1969
1970         if (tsp == NULL)
1971                 return;
1972         cred->security = NULL;
1973
1974         smk_destroy_label_list(&tsp->smk_relabel);
1975
1976         list_for_each_safe(l, n, &tsp->smk_rules) {
1977                 rp = list_entry(l, struct smack_rule, list);
1978                 list_del(&rp->list);
1979                 kfree(rp);
1980         }
1981         kfree(tsp);
1982 }
1983
1984 /**
1985  * smack_cred_prepare - prepare new set of credentials for modification
1986  * @new: the new credentials
1987  * @old: the original credentials
1988  * @gfp: the atomicity of any memory allocations
1989  *
1990  * Prepare a new set of credentials for modification.
1991  */
1992 static int smack_cred_prepare(struct cred *new, const struct cred *old,
1993                               gfp_t gfp)
1994 {
1995         struct task_smack *old_tsp = old->security;
1996         struct task_smack *new_tsp;
1997         int rc;
1998
1999         new_tsp = new_task_smack(old_tsp->smk_task, old_tsp->smk_task, gfp);
2000         if (new_tsp == NULL)
2001                 return -ENOMEM;
2002
2003         new->security = new_tsp;
2004
2005         rc = smk_copy_rules(&new_tsp->smk_rules, &old_tsp->smk_rules, gfp);
2006         if (rc != 0)
2007                 return rc;
2008
2009         rc = smk_copy_relabel(&new_tsp->smk_relabel, &old_tsp->smk_relabel,
2010                                 gfp);
2011         if (rc != 0)
2012                 return rc;
2013
2014         return 0;
2015 }
2016
2017 /**
2018  * smack_cred_transfer - Transfer the old credentials to the new credentials
2019  * @new: the new credentials
2020  * @old: the original credentials
2021  *
2022  * Fill in a set of blank credentials from another set of credentials.
2023  */
2024 static void smack_cred_transfer(struct cred *new, const struct cred *old)
2025 {
2026         struct task_smack *old_tsp = old->security;
2027         struct task_smack *new_tsp = new->security;
2028
2029         new_tsp->smk_task = old_tsp->smk_task;
2030         new_tsp->smk_forked = old_tsp->smk_task;
2031         mutex_init(&new_tsp->smk_rules_lock);
2032         INIT_LIST_HEAD(&new_tsp->smk_rules);
2033
2034
2035         /* cbs copy rule list */
2036 }
2037
2038 /**
2039  * smack_cred_getsecid - get the secid corresponding to a creds structure
2040  * @c: the object creds
2041  * @secid: where to put the result
2042  *
2043  * Sets the secid to contain a u32 version of the smack label.
2044  */
2045 static void smack_cred_getsecid(const struct cred *c, u32 *secid)
2046 {
2047         struct smack_known *skp;
2048
2049         rcu_read_lock();
2050         skp = smk_of_task(c->security);
2051         *secid = skp->smk_secid;
2052         rcu_read_unlock();
2053 }
2054
2055 /**
2056  * smack_kernel_act_as - Set the subjective context in a set of credentials
2057  * @new: points to the set of credentials to be modified.
2058  * @secid: specifies the security ID to be set
2059  *
2060  * Set the security data for a kernel service.
2061  */
2062 static int smack_kernel_act_as(struct cred *new, u32 secid)
2063 {
2064         struct task_smack *new_tsp = new->security;
2065
2066         new_tsp->smk_task = smack_from_secid(secid);
2067         return 0;
2068 }
2069
2070 /**
2071  * smack_kernel_create_files_as - Set the file creation label in a set of creds
2072  * @new: points to the set of credentials to be modified
2073  * @inode: points to the inode to use as a reference
2074  *
2075  * Set the file creation context in a set of credentials to the same
2076  * as the objective context of the specified inode
2077  */
2078 static int smack_kernel_create_files_as(struct cred *new,
2079                                         struct inode *inode)
2080 {
2081         struct inode_smack *isp = inode->i_security;
2082         struct task_smack *tsp = new->security;
2083
2084         tsp->smk_forked = isp->smk_inode;
2085         tsp->smk_task = tsp->smk_forked;
2086         return 0;
2087 }
2088
2089 /**
2090  * smk_curacc_on_task - helper to log task related access
2091  * @p: the task object
2092  * @access: the access requested
2093  * @caller: name of the calling function for audit
2094  *
2095  * Return 0 if access is permitted
2096  */
2097 static int smk_curacc_on_task(struct task_struct *p, int access,
2098                                 const char *caller)
2099 {
2100         struct smk_audit_info ad;
2101         struct smack_known *skp = smk_of_task_struct(p);
2102         int rc;
2103
2104         smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK);
2105         smk_ad_setfield_u_tsk(&ad, p);
2106         rc = smk_curacc(skp, access, &ad);
2107         rc = smk_bu_task(p, access, rc);
2108         return rc;
2109 }
2110
2111 /**
2112  * smack_task_setpgid - Smack check on setting pgid
2113  * @p: the task object
2114  * @pgid: unused
2115  *
2116  * Return 0 if write access is permitted
2117  */
2118 static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
2119 {
2120         return smk_curacc_on_task(p, MAY_WRITE, __func__);
2121 }
2122
2123 /**
2124  * smack_task_getpgid - Smack access check for getpgid
2125  * @p: the object task
2126  *
2127  * Returns 0 if current can read the object task, error code otherwise
2128  */
2129 static int smack_task_getpgid(struct task_struct *p)
2130 {
2131         return smk_curacc_on_task(p, MAY_READ, __func__);
2132 }
2133
2134 /**
2135  * smack_task_getsid - Smack access check for getsid
2136  * @p: the object task
2137  *
2138  * Returns 0 if current can read the object task, error code otherwise
2139  */
2140 static int smack_task_getsid(struct task_struct *p)
2141 {
2142         return smk_curacc_on_task(p, MAY_READ, __func__);
2143 }
2144
2145 /**
2146  * smack_task_getsecid - get the secid of the task
2147  * @p: the object task
2148  * @secid: where to put the result
2149  *
2150  * Sets the secid to contain a u32 version of the smack label.
2151  */
2152 static void smack_task_getsecid(struct task_struct *p, u32 *secid)
2153 {
2154         struct smack_known *skp = smk_of_task_struct(p);
2155
2156         *secid = skp->smk_secid;
2157 }
2158
2159 /**
2160  * smack_task_setnice - Smack check on setting nice
2161  * @p: the task object
2162  * @nice: unused
2163  *
2164  * Return 0 if write access is permitted
2165  */
2166 static int smack_task_setnice(struct task_struct *p, int nice)
2167 {
2168         return smk_curacc_on_task(p, MAY_WRITE, __func__);
2169 }
2170
2171 /**
2172  * smack_task_setioprio - Smack check on setting ioprio
2173  * @p: the task object
2174  * @ioprio: unused
2175  *
2176  * Return 0 if write access is permitted
2177  */
2178 static int smack_task_setioprio(struct task_struct *p, int ioprio)
2179 {
2180         return smk_curacc_on_task(p, MAY_WRITE, __func__);
2181 }
2182
2183 /**
2184  * smack_task_getioprio - Smack check on reading ioprio
2185  * @p: the task object
2186  *
2187  * Return 0 if read access is permitted
2188  */
2189 static int smack_task_getioprio(struct task_struct *p)
2190 {
2191         return smk_curacc_on_task(p, MAY_READ, __func__);
2192 }
2193
2194 /**
2195  * smack_task_setscheduler - Smack check on setting scheduler
2196  * @p: the task object
2197  * @policy: unused
2198  * @lp: unused
2199  *
2200  * Return 0 if read access is permitted
2201  */
2202 static int smack_task_setscheduler(struct task_struct *p)
2203 {
2204         return smk_curacc_on_task(p, MAY_WRITE, __func__);
2205 }
2206
2207 /**
2208  * smack_task_getscheduler - Smack check on reading scheduler
2209  * @p: the task object
2210  *
2211  * Return 0 if read access is permitted
2212  */
2213 static int smack_task_getscheduler(struct task_struct *p)
2214 {
2215         return smk_curacc_on_task(p, MAY_READ, __func__);
2216 }
2217
2218 /**
2219  * smack_task_movememory - Smack check on moving memory
2220  * @p: the task object
2221  *
2222  * Return 0 if write access is permitted
2223  */
2224 static int smack_task_movememory(struct task_struct *p)
2225 {
2226         return smk_curacc_on_task(p, MAY_WRITE, __func__);
2227 }
2228
2229 /**
2230  * smack_task_kill - Smack check on signal delivery
2231  * @p: the task object
2232  * @info: unused
2233  * @sig: unused
2234  * @cred: identifies the cred to use in lieu of current's
2235  *
2236  * Return 0 if write access is permitted
2237  *
2238  */
2239 static int smack_task_kill(struct task_struct *p, struct kernel_siginfo *info,
2240                            int sig, const struct cred *cred)
2241 {
2242         struct smk_audit_info ad;
2243         struct smack_known *skp;
2244         struct smack_known *tkp = smk_of_task_struct(p);
2245         int rc;
2246
2247         if (!sig)
2248                 return 0; /* null signal; existence test */
2249
2250         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
2251         smk_ad_setfield_u_tsk(&ad, p);
2252         /*
2253          * Sending a signal requires that the sender
2254          * can write the receiver.
2255          */
2256         if (cred == NULL) {
2257                 rc = smk_curacc(tkp, MAY_DELIVER, &ad);
2258                 rc = smk_bu_task(p, MAY_DELIVER, rc);
2259                 return rc;
2260         }
2261         /*
2262          * If the cred isn't NULL we're dealing with some USB IO
2263          * specific behavior. This is not clean. For one thing
2264          * we can't take privilege into account.
2265          */
2266         skp = smk_of_task(cred->security);
2267         rc = smk_access(skp, tkp, MAY_DELIVER, &ad);
2268         rc = smk_bu_note("USB signal", skp, tkp, MAY_DELIVER, rc);
2269         return rc;
2270 }
2271
2272 /**
2273  * smack_task_to_inode - copy task smack into the inode blob
2274  * @p: task to copy from
2275  * @inode: inode to copy to
2276  *
2277  * Sets the smack pointer in the inode security blob
2278  */
2279 static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
2280 {
2281         struct inode_smack *isp = inode->i_security;
2282         struct smack_known *skp = smk_of_task_struct(p);
2283
2284         isp->smk_inode = skp;
2285         isp->smk_flags |= SMK_INODE_INSTANT;
2286 }
2287
2288 /*
2289  * Socket hooks.
2290  */
2291
2292 /**
2293  * smack_sk_alloc_security - Allocate a socket blob
2294  * @sk: the socket
2295  * @family: unused
2296  * @gfp_flags: memory allocation flags
2297  *
2298  * Assign Smack pointers to current
2299  *
2300  * Returns 0 on success, -ENOMEM is there's no memory
2301  */
2302 static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
2303 {
2304         struct smack_known *skp = smk_of_current();
2305         struct socket_smack *ssp;
2306
2307         ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
2308         if (ssp == NULL)
2309                 return -ENOMEM;
2310
2311         /*
2312          * Sockets created by kernel threads receive web label.
2313          */
2314         if (unlikely(current->flags & PF_KTHREAD)) {
2315                 ssp->smk_in = &smack_known_web;
2316                 ssp->smk_out = &smack_known_web;
2317         } else {
2318                 ssp->smk_in = skp;
2319                 ssp->smk_out = skp;
2320         }
2321         ssp->smk_packet = NULL;
2322
2323         sk->sk_security = ssp;
2324
2325         return 0;
2326 }
2327
2328 /**
2329  * smack_sk_free_security - Free a socket blob
2330  * @sk: the socket
2331  *
2332  * Clears the blob pointer
2333  */
2334 static void smack_sk_free_security(struct sock *sk)
2335 {
2336 #ifdef SMACK_IPV6_PORT_LABELING
2337         struct smk_port_label *spp;
2338
2339         if (sk->sk_family == PF_INET6) {
2340                 rcu_read_lock();
2341                 list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
2342                         if (spp->smk_sock != sk)
2343                                 continue;
2344                         spp->smk_can_reuse = 1;
2345                         break;
2346                 }
2347                 rcu_read_unlock();
2348         }
2349 #endif
2350         kfree(sk->sk_security);
2351 }
2352
2353 /**
2354 * smack_ipv4host_label - check host based restrictions
2355 * @sip: the object end
2356 *
2357 * looks for host based access restrictions
2358 *
2359 * This version will only be appropriate for really small sets of single label
2360 * hosts.  The caller is responsible for ensuring that the RCU read lock is
2361 * taken before calling this function.
2362 *
2363 * Returns the label of the far end or NULL if it's not special.
2364 */
2365 static struct smack_known *smack_ipv4host_label(struct sockaddr_in *sip)
2366 {
2367         struct smk_net4addr *snp;
2368         struct in_addr *siap = &sip->sin_addr;
2369
2370         if (siap->s_addr == 0)
2371                 return NULL;
2372
2373         list_for_each_entry_rcu(snp, &smk_net4addr_list, list)
2374                 /*
2375                  * we break after finding the first match because
2376                  * the list is sorted from longest to shortest mask
2377                  * so we have found the most specific match
2378                  */
2379                 if (snp->smk_host.s_addr ==
2380                     (siap->s_addr & snp->smk_mask.s_addr))
2381                         return snp->smk_label;
2382
2383         return NULL;
2384 }
2385
2386 #if IS_ENABLED(CONFIG_IPV6)
2387 /*
2388  * smk_ipv6_localhost - Check for local ipv6 host address
2389  * @sip: the address
2390  *
2391  * Returns boolean true if this is the localhost address
2392  */
2393 static bool smk_ipv6_localhost(struct sockaddr_in6 *sip)
2394 {
2395         __be16 *be16p = (__be16 *)&sip->sin6_addr;
2396         __be32 *be32p = (__be32 *)&sip->sin6_addr;
2397
2398         if (be32p[0] == 0 && be32p[1] == 0 && be32p[2] == 0 && be16p[6] == 0 &&
2399             ntohs(be16p[7]) == 1)
2400                 return true;
2401         return false;
2402 }
2403
2404 /**
2405 * smack_ipv6host_label - check host based restrictions
2406 * @sip: the object end
2407 *
2408 * looks for host based access restrictions
2409 *
2410 * This version will only be appropriate for really small sets of single label
2411 * hosts.  The caller is responsible for ensuring that the RCU read lock is
2412 * taken before calling this function.
2413 *
2414 * Returns the label of the far end or NULL if it's not special.
2415 */
2416 static struct smack_known *smack_ipv6host_label(struct sockaddr_in6 *sip)
2417 {
2418         struct smk_net6addr *snp;
2419         struct in6_addr *sap = &sip->sin6_addr;
2420         int i;
2421         int found = 0;
2422
2423         /*
2424          * It's local. Don't look for a host label.
2425          */
2426         if (smk_ipv6_localhost(sip))
2427                 return NULL;
2428
2429         list_for_each_entry_rcu(snp, &smk_net6addr_list, list) {
2430                 /*
2431                  * If the label is NULL the entry has
2432                  * been renounced. Ignore it.
2433                  */
2434                 if (snp->smk_label == NULL)
2435                         continue;
2436                 /*
2437                 * we break after finding the first match because
2438                 * the list is sorted from longest to shortest mask
2439                 * so we have found the most specific match
2440                 */
2441                 for (found = 1, i = 0; i < 8; i++) {
2442                         if ((sap->s6_addr16[i] & snp->smk_mask.s6_addr16[i]) !=
2443                             snp->smk_host.s6_addr16[i]) {
2444                                 found = 0;
2445                                 break;
2446                         }
2447                 }
2448                 if (found)
2449                         return snp->smk_label;
2450         }
2451
2452         return NULL;
2453 }
2454 #endif /* CONFIG_IPV6 */
2455
2456 /**
2457  * smack_netlabel - Set the secattr on a socket
2458  * @sk: the socket
2459  * @labeled: socket label scheme
2460  *
2461  * Convert the outbound smack value (smk_out) to a
2462  * secattr and attach it to the socket.
2463  *
2464  * Returns 0 on success or an error code
2465  */
2466 static int smack_netlabel(struct sock *sk, int labeled)
2467 {
2468         struct smack_known *skp;
2469         struct socket_smack *ssp = sk->sk_security;
2470         int rc = 0;
2471
2472         /*
2473          * Usually the netlabel code will handle changing the
2474          * packet labeling based on the label.
2475          * The case of a single label host is different, because
2476          * a single label host should never get a labeled packet
2477          * even though the label is usually associated with a packet
2478          * label.
2479          */
2480         local_bh_disable();
2481         bh_lock_sock_nested(sk);
2482
2483         if (ssp->smk_out == smack_net_ambient ||
2484             labeled == SMACK_UNLABELED_SOCKET)
2485                 netlbl_sock_delattr(sk);
2486         else {
2487                 skp = ssp->smk_out;
2488                 rc = netlbl_sock_setattr(sk, sk->sk_family, &skp->smk_netlabel);
2489         }
2490
2491         bh_unlock_sock(sk);
2492         local_bh_enable();
2493
2494         return rc;
2495 }
2496
2497 /**
2498  * smack_netlbel_send - Set the secattr on a socket and perform access checks
2499  * @sk: the socket
2500  * @sap: the destination address
2501  *
2502  * Set the correct secattr for the given socket based on the destination
2503  * address and perform any outbound access checks needed.
2504  *
2505  * Returns 0 on success or an error code.
2506  *
2507  */
2508 static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
2509 {
2510         struct smack_known *skp;
2511         int rc;
2512         int sk_lbl;
2513         struct smack_known *hkp;
2514         struct socket_smack *ssp = sk->sk_security;
2515         struct smk_audit_info ad;
2516
2517         rcu_read_lock();
2518         hkp = smack_ipv4host_label(sap);
2519         if (hkp != NULL) {
2520 #ifdef CONFIG_AUDIT
2521                 struct lsm_network_audit net;
2522
2523                 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2524                 ad.a.u.net->family = sap->sin_family;
2525                 ad.a.u.net->dport = sap->sin_port;
2526                 ad.a.u.net->v4info.daddr = sap->sin_addr.s_addr;
2527 #endif
2528                 sk_lbl = SMACK_UNLABELED_SOCKET;
2529                 skp = ssp->smk_out;
2530                 rc = smk_access(skp, hkp, MAY_WRITE, &ad);
2531                 rc = smk_bu_note("IPv4 host check", skp, hkp, MAY_WRITE, rc);
2532         } else {
2533                 sk_lbl = SMACK_CIPSO_SOCKET;
2534                 rc = 0;
2535         }
2536         rcu_read_unlock();
2537         if (rc != 0)
2538                 return rc;
2539
2540         return smack_netlabel(sk, sk_lbl);
2541 }
2542
2543 #if IS_ENABLED(CONFIG_IPV6)
2544 /**
2545  * smk_ipv6_check - check Smack access
2546  * @subject: subject Smack label
2547  * @object: object Smack label
2548  * @address: address
2549  * @act: the action being taken
2550  *
2551  * Check an IPv6 access
2552  */
2553 static int smk_ipv6_check(struct smack_known *subject,
2554                                 struct smack_known *object,
2555                                 struct sockaddr_in6 *address, int act)
2556 {
2557 #ifdef CONFIG_AUDIT
2558         struct lsm_network_audit net;
2559 #endif
2560         struct smk_audit_info ad;
2561         int rc;
2562
2563 #ifdef CONFIG_AUDIT
2564         smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2565         ad.a.u.net->family = PF_INET6;
2566         ad.a.u.net->dport = ntohs(address->sin6_port);
2567         if (act == SMK_RECEIVING)
2568                 ad.a.u.net->v6info.saddr = address->sin6_addr;
2569         else
2570                 ad.a.u.net->v6info.daddr = address->sin6_addr;
2571 #endif
2572         rc = smk_access(subject, object, MAY_WRITE, &ad);
2573         rc = smk_bu_note("IPv6 check", subject, object, MAY_WRITE, rc);
2574         return rc;
2575 }
2576 #endif /* CONFIG_IPV6 */
2577
2578 #ifdef SMACK_IPV6_PORT_LABELING
2579 /**
2580  * smk_ipv6_port_label - Smack port access table management
2581  * @sock: socket
2582  * @address: address
2583  *
2584  * Create or update the port list entry
2585  */
2586 static void smk_ipv6_port_label(struct socket *sock, struct sockaddr *address)
2587 {
2588         struct sock *sk = sock->sk;
2589         struct sockaddr_in6 *addr6;
2590         struct socket_smack *ssp = sock->sk->sk_security;
2591         struct smk_port_label *spp;
2592         unsigned short port = 0;
2593
2594         if (address == NULL) {
2595                 /*
2596                  * This operation is changing the Smack information
2597                  * on the bound socket. Take the changes to the port
2598                  * as well.
2599                  */
2600                 rcu_read_lock();
2601                 list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
2602                         if (sk != spp->smk_sock)
2603                                 continue;
2604                         spp->smk_in = ssp->smk_in;
2605                         spp->smk_out = ssp->smk_out;
2606                         rcu_read_unlock();
2607                         return;
2608                 }
2609                 /*
2610                  * A NULL address is only used for updating existing
2611                  * bound entries. If there isn't one, it's OK.
2612                  */
2613                 rcu_read_unlock();
2614                 return;
2615         }
2616
2617         addr6 = (struct sockaddr_in6 *)address;
2618         port = ntohs(addr6->sin6_port);
2619         /*
2620          * This is a special case that is safely ignored.
2621          */
2622         if (port == 0)
2623                 return;
2624
2625         /*
2626          * Look for an existing port list entry.
2627          * This is an indication that a port is getting reused.
2628          */
2629         rcu_read_lock();
2630         list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
2631                 if (spp->smk_port != port || spp->smk_sock_type != sock->type)
2632                         continue;
2633                 if (spp->smk_can_reuse != 1) {
2634                         rcu_read_unlock();
2635                         return;
2636                 }
2637                 spp->smk_port = port;
2638                 spp->smk_sock = sk;
2639                 spp->smk_in = ssp->smk_in;
2640                 spp->smk_out = ssp->smk_out;
2641                 spp->smk_can_reuse = 0;
2642                 rcu_read_unlock();
2643                 return;
2644         }
2645         rcu_read_unlock();
2646         /*
2647          * A new port entry is required.
2648          */
2649         spp = kzalloc(sizeof(*spp), GFP_KERNEL);
2650         if (spp == NULL)
2651                 return;
2652
2653         spp->smk_port = port;
2654         spp->smk_sock = sk;
2655         spp->smk_in = ssp->smk_in;
2656         spp->smk_out = ssp->smk_out;
2657         spp->smk_sock_type = sock->type;
2658         spp->smk_can_reuse = 0;
2659
2660         mutex_lock(&smack_ipv6_lock);
2661         list_add_rcu(&spp->list, &smk_ipv6_port_list);
2662         mutex_unlock(&smack_ipv6_lock);
2663         return;
2664 }
2665
2666 /**
2667  * smk_ipv6_port_check - check Smack port access
2668  * @sock: socket
2669  * @address: address
2670  *
2671  * Create or update the port list entry
2672  */
2673 static int smk_ipv6_port_check(struct sock *sk, struct sockaddr_in6 *address,
2674                                 int act)
2675 {
2676         struct smk_port_label *spp;
2677         struct socket_smack *ssp = sk->sk_security;
2678         struct smack_known *skp = NULL;
2679         unsigned short port;
2680         struct smack_known *object;
2681
2682         if (act == SMK_RECEIVING) {
2683                 skp = smack_ipv6host_label(address);
2684                 object = ssp->smk_in;
2685         } else {
2686                 skp = ssp->smk_out;
2687                 object = smack_ipv6host_label(address);
2688         }
2689
2690         /*
2691          * The other end is a single label host.
2692          */
2693         if (skp != NULL && object != NULL)
2694                 return smk_ipv6_check(skp, object, address, act);
2695         if (skp == NULL)
2696                 skp = smack_net_ambient;
2697         if (object == NULL)
2698                 object = smack_net_ambient;
2699
2700         /*
2701          * It's remote, so port lookup does no good.
2702          */
2703         if (!smk_ipv6_localhost(address))
2704                 return smk_ipv6_check(skp, object, address, act);
2705
2706         /*
2707          * It's local so the send check has to have passed.
2708          */
2709         if (act == SMK_RECEIVING)
2710                 return 0;
2711
2712         port = ntohs(address->sin6_port);
2713         rcu_read_lock();
2714         list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
2715                 if (spp->smk_port != port || spp->smk_sock_type != sk->sk_type)
2716                         continue;
2717                 object = spp->smk_in;
2718                 if (act == SMK_CONNECTING)
2719                         ssp->smk_packet = spp->smk_out;
2720                 break;
2721         }
2722         rcu_read_unlock();
2723
2724         return smk_ipv6_check(skp, object, address, act);
2725 }
2726 #endif /* SMACK_IPV6_PORT_LABELING */
2727
2728 /**
2729  * smack_inode_setsecurity - set smack xattrs
2730  * @inode: the object
2731  * @name: attribute name
2732  * @value: attribute value
2733  * @size: size of the attribute
2734  * @flags: unused
2735  *
2736  * Sets the named attribute in the appropriate blob
2737  *
2738  * Returns 0 on success, or an error code
2739  */
2740 static int smack_inode_setsecurity(struct inode *inode, const char *name,
2741                                    const void *value, size_t size, int flags)
2742 {
2743         struct smack_known *skp;
2744         struct inode_smack *nsp = inode->i_security;
2745         struct socket_smack *ssp;
2746         struct socket *sock;
2747         int rc = 0;
2748
2749         if (value == NULL || size > SMK_LONGLABEL || size == 0)
2750                 return -EINVAL;
2751
2752         skp = smk_import_entry(value, size);
2753         if (IS_ERR(skp))
2754                 return PTR_ERR(skp);
2755
2756         if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
2757                 nsp->smk_inode = skp;
2758                 nsp->smk_flags |= SMK_INODE_INSTANT;
2759                 return 0;
2760         }
2761         /*
2762          * The rest of the Smack xattrs are only on sockets.
2763          */
2764         if (inode->i_sb->s_magic != SOCKFS_MAGIC)
2765                 return -EOPNOTSUPP;
2766
2767         sock = SOCKET_I(inode);
2768         if (sock == NULL || sock->sk == NULL)
2769                 return -EOPNOTSUPP;
2770
2771         ssp = sock->sk->sk_security;
2772
2773         if (strcmp(name, XATTR_SMACK_IPIN) == 0)
2774                 ssp->smk_in = skp;
2775         else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
2776                 ssp->smk_out = skp;
2777                 if (sock->sk->sk_family == PF_INET) {
2778                         rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2779                         if (rc != 0)
2780                                 printk(KERN_WARNING
2781                                         "Smack: \"%s\" netlbl error %d.\n",
2782                                         __func__, -rc);
2783                 }
2784         } else
2785                 return -EOPNOTSUPP;
2786
2787 #ifdef SMACK_IPV6_PORT_LABELING
2788         if (sock->sk->sk_family == PF_INET6)
2789                 smk_ipv6_port_label(sock, NULL);
2790 #endif
2791
2792         return 0;
2793 }
2794
2795 /**
2796  * smack_socket_post_create - finish socket setup
2797  * @sock: the socket
2798  * @family: protocol family
2799  * @type: unused
2800  * @protocol: unused
2801  * @kern: unused
2802  *
2803  * Sets the netlabel information on the socket
2804  *
2805  * Returns 0 on success, and error code otherwise
2806  */
2807 static int smack_socket_post_create(struct socket *sock, int family,
2808                                     int type, int protocol, int kern)
2809 {
2810         struct socket_smack *ssp;
2811
2812         if (sock->sk == NULL)
2813                 return 0;
2814
2815         /*
2816          * Sockets created by kernel threads receive web label.
2817          */
2818         if (unlikely(current->flags & PF_KTHREAD)) {
2819                 ssp = sock->sk->sk_security;
2820                 ssp->smk_in = &smack_known_web;
2821                 ssp->smk_out = &smack_known_web;
2822         }
2823
2824         if (family != PF_INET)
2825                 return 0;
2826         /*
2827          * Set the outbound netlbl.
2828          */
2829         return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2830 }
2831
2832 /**
2833  * smack_socket_socketpair - create socket pair
2834  * @socka: one socket
2835  * @sockb: another socket
2836  *
2837  * Cross reference the peer labels for SO_PEERSEC
2838  *
2839  * Returns 0 on success, and error code otherwise
2840  */
2841 static int smack_socket_socketpair(struct socket *socka,
2842                                    struct socket *sockb)
2843 {
2844         struct socket_smack *asp = socka->sk->sk_security;
2845         struct socket_smack *bsp = sockb->sk->sk_security;
2846
2847         asp->smk_packet = bsp->smk_out;
2848         bsp->smk_packet = asp->smk_out;
2849
2850         return 0;
2851 }
2852
2853 #ifdef SMACK_IPV6_PORT_LABELING
2854 /**
2855  * smack_socket_bind - record port binding information.
2856  * @sock: the socket
2857  * @address: the port address
2858  * @addrlen: size of the address
2859  *
2860  * Records the label bound to a port.
2861  *
2862  * Returns 0
2863  */
2864 static int smack_socket_bind(struct socket *sock, struct sockaddr *address,
2865                                 int addrlen)
2866 {
2867         if (sock->sk != NULL && sock->sk->sk_family == PF_INET6)
2868                 smk_ipv6_port_label(sock, address);
2869         return 0;
2870 }
2871 #endif /* SMACK_IPV6_PORT_LABELING */
2872
2873 /**
2874  * smack_socket_connect - connect access check
2875  * @sock: the socket
2876  * @sap: the other end
2877  * @addrlen: size of sap
2878  *
2879  * Verifies that a connection may be possible
2880  *
2881  * Returns 0 on success, and error code otherwise
2882  */
2883 static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
2884                                 int addrlen)
2885 {
2886         int rc = 0;
2887 #if IS_ENABLED(CONFIG_IPV6)
2888         struct sockaddr_in6 *sip = (struct sockaddr_in6 *)sap;
2889 #endif
2890 #ifdef SMACK_IPV6_SECMARK_LABELING
2891         struct smack_known *rsp;
2892         struct socket_smack *ssp;
2893 #endif
2894
2895         if (sock->sk == NULL)
2896                 return 0;
2897
2898 #ifdef SMACK_IPV6_SECMARK_LABELING
2899         ssp = sock->sk->sk_security;
2900 #endif
2901
2902         switch (sock->sk->sk_family) {
2903         case PF_INET:
2904                 if (addrlen < sizeof(struct sockaddr_in))
2905                         return -EINVAL;
2906                 rc = smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap);
2907                 break;
2908         case PF_INET6:
2909                 if (addrlen < sizeof(struct sockaddr_in6))
2910                         return -EINVAL;
2911 #ifdef SMACK_IPV6_SECMARK_LABELING
2912                 rsp = smack_ipv6host_label(sip);
2913                 if (rsp != NULL)
2914                         rc = smk_ipv6_check(ssp->smk_out, rsp, sip,
2915                                                 SMK_CONNECTING);
2916 #endif
2917 #ifdef SMACK_IPV6_PORT_LABELING
2918                 rc = smk_ipv6_port_check(sock->sk, sip, SMK_CONNECTING);
2919 #endif
2920                 break;
2921         }
2922         return rc;
2923 }
2924
2925 /**
2926  * smack_flags_to_may - convert S_ to MAY_ values
2927  * @flags: the S_ value
2928  *
2929  * Returns the equivalent MAY_ value
2930  */
2931 static int smack_flags_to_may(int flags)
2932 {
2933         int may = 0;
2934
2935         if (flags & S_IRUGO)
2936                 may |= MAY_READ;
2937         if (flags & S_IWUGO)
2938                 may |= MAY_WRITE;
2939         if (flags & S_IXUGO)
2940                 may |= MAY_EXEC;
2941
2942         return may;
2943 }
2944
2945 /**
2946  * smack_msg_msg_alloc_security - Set the security blob for msg_msg
2947  * @msg: the object
2948  *
2949  * Returns 0
2950  */
2951 static int smack_msg_msg_alloc_security(struct msg_msg *msg)
2952 {
2953         struct smack_known *skp = smk_of_current();
2954
2955         msg->security = skp;
2956         return 0;
2957 }
2958
2959 /**
2960  * smack_msg_msg_free_security - Clear the security blob for msg_msg
2961  * @msg: the object
2962  *
2963  * Clears the blob pointer
2964  */
2965 static void smack_msg_msg_free_security(struct msg_msg *msg)
2966 {
2967         msg->security = NULL;
2968 }
2969
2970 /**
2971  * smack_of_ipc - the smack pointer for the ipc
2972  * @isp: the object
2973  *
2974  * Returns a pointer to the smack value
2975  */
2976 static struct smack_known *smack_of_ipc(struct kern_ipc_perm *isp)
2977 {
2978         return (struct smack_known *)isp->security;
2979 }
2980
2981 /**
2982  * smack_ipc_alloc_security - Set the security blob for ipc
2983  * @isp: the object
2984  *
2985  * Returns 0
2986  */
2987 static int smack_ipc_alloc_security(struct kern_ipc_perm *isp)
2988 {
2989         struct smack_known *skp = smk_of_current();
2990
2991         isp->security = skp;
2992         return 0;
2993 }
2994
2995 /**
2996  * smack_ipc_free_security - Clear the security blob for ipc
2997  * @isp: the object
2998  *
2999  * Clears the blob pointer
3000  */
3001 static void smack_ipc_free_security(struct kern_ipc_perm *isp)
3002 {
3003         isp->security = NULL;
3004 }
3005
3006 /**
3007  * smk_curacc_shm : check if current has access on shm
3008  * @isp : the object
3009  * @access : access requested
3010  *
3011  * Returns 0 if current has the requested access, error code otherwise
3012  */
3013 static int smk_curacc_shm(struct kern_ipc_perm *isp, int access)
3014 {
3015         struct smack_known *ssp = smack_of_ipc(isp);
3016         struct smk_audit_info ad;
3017         int rc;
3018
3019 #ifdef CONFIG_AUDIT
3020         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
3021         ad.a.u.ipc_id = isp->id;
3022 #endif
3023         rc = smk_curacc(ssp, access, &ad);
3024         rc = smk_bu_current("shm", ssp, access, rc);
3025         return rc;
3026 }
3027
3028 /**
3029  * smack_shm_associate - Smack access check for shm
3030  * @isp: the object
3031  * @shmflg: access requested
3032  *
3033  * Returns 0 if current has the requested access, error code otherwise
3034  */
3035 static int smack_shm_associate(struct kern_ipc_perm *isp, int shmflg)
3036 {
3037         int may;
3038
3039         may = smack_flags_to_may(shmflg);
3040         return smk_curacc_shm(isp, may);
3041 }
3042
3043 /**
3044  * smack_shm_shmctl - Smack access check for shm
3045  * @isp: the object
3046  * @cmd: what it wants to do
3047  *
3048  * Returns 0 if current has the requested access, error code otherwise
3049  */
3050 static int smack_shm_shmctl(struct kern_ipc_perm *isp, int cmd)
3051 {
3052         int may;
3053
3054         switch (cmd) {
3055         case IPC_STAT:
3056         case SHM_STAT:
3057         case SHM_STAT_ANY:
3058                 may = MAY_READ;
3059                 break;
3060         case IPC_SET:
3061         case SHM_LOCK:
3062         case SHM_UNLOCK:
3063         case IPC_RMID:
3064                 may = MAY_READWRITE;
3065                 break;
3066         case IPC_INFO:
3067         case SHM_INFO:
3068                 /*
3069                  * System level information.
3070                  */
3071                 return 0;
3072         default:
3073                 return -EINVAL;
3074         }
3075         return smk_curacc_shm(isp, may);
3076 }
3077
3078 /**
3079  * smack_shm_shmat - Smack access for shmat
3080  * @isp: the object
3081  * @shmaddr: unused
3082  * @shmflg: access requested
3083  *
3084  * Returns 0 if current has the requested access, error code otherwise
3085  */
3086 static int smack_shm_shmat(struct kern_ipc_perm *ipc, char __user *shmaddr,
3087                            int shmflg)
3088 {
3089         int may;
3090
3091         may = smack_flags_to_may(shmflg);
3092         return smk_curacc_shm(ipc, may);
3093 }
3094
3095 /**
3096  * smk_curacc_sem : check if current has access on sem
3097  * @isp : the object
3098  * @access : access requested
3099  *
3100  * Returns 0 if current has the requested access, error code otherwise
3101  */
3102 static int smk_curacc_sem(struct kern_ipc_perm *isp, int access)
3103 {
3104         struct smack_known *ssp = smack_of_ipc(isp);
3105         struct smk_audit_info ad;
3106         int rc;
3107
3108 #ifdef CONFIG_AUDIT
3109         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
3110         ad.a.u.ipc_id = isp->id;
3111 #endif
3112         rc = smk_curacc(ssp, access, &ad);
3113         rc = smk_bu_current("sem", ssp, access, rc);
3114         return rc;
3115 }
3116
3117 /**
3118  * smack_sem_associate - Smack access check for sem
3119  * @isp: the object
3120  * @semflg: access requested
3121  *
3122  * Returns 0 if current has the requested access, error code otherwise
3123  */
3124 static int smack_sem_associate(struct kern_ipc_perm *isp, int semflg)
3125 {
3126         int may;
3127
3128         may = smack_flags_to_may(semflg);
3129         return smk_curacc_sem(isp, may);
3130 }
3131
3132 /**
3133  * smack_sem_shmctl - Smack access check for sem
3134  * @isp: the object
3135  * @cmd: what it wants to do
3136  *
3137  * Returns 0 if current has the requested access, error code otherwise
3138  */
3139 static int smack_sem_semctl(struct kern_ipc_perm *isp, int cmd)
3140 {
3141         int may;
3142
3143         switch (cmd) {
3144         case GETPID:
3145         case GETNCNT:
3146         case GETZCNT:
3147         case GETVAL:
3148         case GETALL:
3149         case IPC_STAT:
3150         case SEM_STAT:
3151         case SEM_STAT_ANY:
3152                 may = MAY_READ;
3153                 break;
3154         case SETVAL:
3155         case SETALL:
3156         case IPC_RMID:
3157         case IPC_SET:
3158                 may = MAY_READWRITE;
3159                 break;
3160         case IPC_INFO:
3161         case SEM_INFO:
3162                 /*
3163                  * System level information
3164                  */
3165                 return 0;
3166         default:
3167                 return -EINVAL;
3168         }
3169
3170         return smk_curacc_sem(isp, may);
3171 }
3172
3173 /**
3174  * smack_sem_semop - Smack checks of semaphore operations
3175  * @isp: the object
3176  * @sops: unused
3177  * @nsops: unused
3178  * @alter: unused
3179  *
3180  * Treated as read and write in all cases.
3181  *
3182  * Returns 0 if access is allowed, error code otherwise
3183  */
3184 static int smack_sem_semop(struct kern_ipc_perm *isp, struct sembuf *sops,
3185                            unsigned nsops, int alter)
3186 {
3187         return smk_curacc_sem(isp, MAY_READWRITE);
3188 }
3189
3190 /**
3191  * smk_curacc_msq : helper to check if current has access on msq
3192  * @isp : the msq
3193  * @access : access requested
3194  *
3195  * return 0 if current has access, error otherwise
3196  */
3197 static int smk_curacc_msq(struct kern_ipc_perm *isp, int access)
3198 {
3199         struct smack_known *msp = smack_of_ipc(isp);
3200         struct smk_audit_info ad;
3201         int rc;
3202
3203 #ifdef CONFIG_AUDIT
3204         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
3205         ad.a.u.ipc_id = isp->id;
3206 #endif
3207         rc = smk_curacc(msp, access, &ad);
3208         rc = smk_bu_current("msq", msp, access, rc);
3209         return rc;
3210 }
3211
3212 /**
3213  * smack_msg_queue_associate - Smack access check for msg_queue
3214  * @isp: the object
3215  * @msqflg: access requested
3216  *
3217  * Returns 0 if current has the requested access, error code otherwise
3218  */
3219 static int smack_msg_queue_associate(struct kern_ipc_perm *isp, int msqflg)
3220 {
3221         int may;
3222
3223         may = smack_flags_to_may(msqflg);
3224         return smk_curacc_msq(isp, may);
3225 }
3226
3227 /**
3228  * smack_msg_queue_msgctl - Smack access check for msg_queue
3229  * @isp: the object
3230  * @cmd: what it wants to do
3231  *
3232  * Returns 0 if current has the requested access, error code otherwise
3233  */
3234 static int smack_msg_queue_msgctl(struct kern_ipc_perm *isp, int cmd)
3235 {
3236         int may;
3237
3238         switch (cmd) {
3239         case IPC_STAT:
3240         case MSG_STAT:
3241         case MSG_STAT_ANY:
3242                 may = MAY_READ;
3243                 break;
3244         case IPC_SET:
3245         case IPC_RMID:
3246                 may = MAY_READWRITE;
3247                 break;
3248         case IPC_INFO:
3249         case MSG_INFO:
3250                 /*
3251                  * System level information
3252                  */
3253                 return 0;
3254         default:
3255                 return -EINVAL;
3256         }
3257
3258         return smk_curacc_msq(isp, may);
3259 }
3260
3261 /**
3262  * smack_msg_queue_msgsnd - Smack access check for msg_queue
3263  * @isp: the object
3264  * @msg: unused
3265  * @msqflg: access requested
3266  *
3267  * Returns 0 if current has the requested access, error code otherwise
3268  */
3269 static int smack_msg_queue_msgsnd(struct kern_ipc_perm *isp, struct msg_msg *msg,
3270                                   int msqflg)
3271 {
3272         int may;
3273
3274         may = smack_flags_to_may(msqflg);
3275         return smk_curacc_msq(isp, may);
3276 }
3277
3278 /**
3279  * smack_msg_queue_msgsnd - Smack access check for msg_queue
3280  * @isp: the object
3281  * @msg: unused
3282  * @target: unused
3283  * @type: unused
3284  * @mode: unused
3285  *
3286  * Returns 0 if current has read and write access, error code otherwise
3287  */
3288 static int smack_msg_queue_msgrcv(struct kern_ipc_perm *isp, struct msg_msg *msg,
3289                         struct task_struct *target, long type, int mode)
3290 {
3291         return smk_curacc_msq(isp, MAY_READWRITE);
3292 }
3293
3294 /**
3295  * smack_ipc_permission - Smack access for ipc_permission()
3296  * @ipp: the object permissions
3297  * @flag: access requested
3298  *
3299  * Returns 0 if current has read and write access, error code otherwise
3300  */
3301 static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
3302 {
3303         struct smack_known *iskp = ipp->security;
3304         int may = smack_flags_to_may(flag);
3305         struct smk_audit_info ad;
3306         int rc;
3307
3308 #ifdef CONFIG_AUDIT
3309         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
3310         ad.a.u.ipc_id = ipp->id;
3311 #endif
3312         rc = smk_curacc(iskp, may, &ad);
3313         rc = smk_bu_current("svipc", iskp, may, rc);
3314         return rc;
3315 }
3316
3317 /**
3318  * smack_ipc_getsecid - Extract smack security id
3319  * @ipp: the object permissions
3320  * @secid: where result will be saved
3321  */
3322 static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
3323 {
3324         struct smack_known *iskp = ipp->security;
3325
3326         *secid = iskp->smk_secid;
3327 }
3328
3329 /**
3330  * smack_d_instantiate - Make sure the blob is correct on an inode
3331  * @opt_dentry: dentry where inode will be attached
3332  * @inode: the object
3333  *
3334  * Set the inode's security blob if it hasn't been done already.
3335  */
3336 static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
3337 {
3338         struct super_block *sbp;
3339         struct superblock_smack *sbsp;
3340         struct inode_smack *isp;
3341         struct smack_known *skp;
3342         struct smack_known *ckp = smk_of_current();
3343         struct smack_known *final;
3344         char trattr[TRANS_TRUE_SIZE];
3345         int transflag = 0;
3346         int rc;
3347         struct dentry *dp;
3348
3349         if (inode == NULL)
3350                 return;
3351
3352         isp = inode->i_security;
3353
3354         mutex_lock(&isp->smk_lock);
3355         /*
3356          * If the inode is already instantiated
3357          * take the quick way out
3358          */
3359         if (isp->smk_flags & SMK_INODE_INSTANT)
3360                 goto unlockandout;
3361
3362         sbp = inode->i_sb;
3363         sbsp = sbp->s_security;
3364         /*
3365          * We're going to use the superblock default label
3366          * if there's no label on the file.
3367          */
3368         final = sbsp->smk_default;
3369
3370         /*
3371          * If this is the root inode the superblock
3372          * may be in the process of initialization.
3373          * If that is the case use the root value out
3374          * of the superblock.
3375          */
3376         if (opt_dentry->d_parent == opt_dentry) {
3377                 switch (sbp->s_magic) {
3378                 case CGROUP_SUPER_MAGIC:
3379                 case CGROUP2_SUPER_MAGIC:
3380                         /*
3381                          * The cgroup filesystem is never mounted,
3382                          * so there's no opportunity to set the mount
3383                          * options.
3384                          */
3385                         sbsp->smk_root = &smack_known_star;
3386                         sbsp->smk_default = &smack_known_star;
3387                         isp->smk_inode = sbsp->smk_root;
3388                         break;
3389                 case TMPFS_MAGIC:
3390                         /*
3391                          * What about shmem/tmpfs anonymous files with dentry
3392                          * obtained from d_alloc_pseudo()?
3393                          */
3394                         isp->smk_inode = smk_of_current();
3395                         break;
3396                 case PIPEFS_MAGIC:
3397                         isp->smk_inode = smk_of_current();
3398                         break;
3399                 case SOCKFS_MAGIC:
3400                         /*
3401                          * Socket access is controlled by the socket
3402                          * structures associated with the task involved.
3403                          */
3404                         isp->smk_inode = &smack_known_star;
3405                         break;
3406                 default:
3407                         isp->smk_inode = sbsp->smk_root;
3408                         break;
3409                 }
3410                 isp->smk_flags |= SMK_INODE_INSTANT;
3411                 goto unlockandout;
3412         }
3413
3414         /*
3415          * This is pretty hackish.
3416          * Casey says that we shouldn't have to do
3417          * file system specific code, but it does help
3418          * with keeping it simple.
3419          */
3420         switch (sbp->s_magic) {
3421         case SMACK_MAGIC:
3422         case CGROUP_SUPER_MAGIC:
3423         case CGROUP2_SUPER_MAGIC:
3424                 /*
3425                  * Casey says that it's a little embarrassing
3426                  * that the smack file system doesn't do
3427                  * extended attributes.
3428                  *
3429                  * Cgroupfs is special
3430                  */
3431                 final = &smack_known_star;
3432                 break;
3433         case DEVPTS_SUPER_MAGIC:
3434                 /*
3435                  * devpts seems content with the label of the task.
3436                  * Programs that change smack have to treat the
3437                  * pty with respect.
3438                  */
3439                 final = ckp;
3440                 break;
3441         case PROC_SUPER_MAGIC:
3442                 /*
3443                  * Casey says procfs appears not to care.
3444                  * The superblock default suffices.
3445                  */
3446                 break;
3447         case TMPFS_MAGIC:
3448                 /*
3449                  * Device labels should come from the filesystem,
3450                  * but watch out, because they're volitile,
3451                  * getting recreated on every reboot.
3452                  */
3453                 final = &smack_known_star;
3454                 /*
3455                  * Fall through.
3456                  *
3457                  * If a smack value has been set we want to use it,
3458                  * but since tmpfs isn't giving us the opportunity
3459                  * to set mount options simulate setting the
3460                  * superblock default.
3461                  */
3462         default:
3463                 /*
3464                  * This isn't an understood special case.
3465                  * Get the value from the xattr.
3466                  */
3467
3468                 /*
3469                  * UNIX domain sockets use lower level socket data.
3470                  */
3471                 if (S_ISSOCK(inode->i_mode)) {
3472                         final = &smack_known_star;
3473                         break;
3474                 }
3475                 /*
3476                  * No xattr support means, alas, no SMACK label.
3477                  * Use the aforeapplied default.
3478                  * It would be curious if the label of the task
3479                  * does not match that assigned.
3480                  */
3481                 if (!(inode->i_opflags & IOP_XATTR))
3482                         break;
3483                 /*
3484                  * Get the dentry for xattr.
3485                  */
3486                 dp = dget(opt_dentry);
3487                 skp = smk_fetch(XATTR_NAME_SMACK, inode, dp);
3488                 if (!IS_ERR_OR_NULL(skp))
3489                         final = skp;
3490
3491                 /*
3492                  * Transmuting directory
3493                  */
3494                 if (S_ISDIR(inode->i_mode)) {
3495                         /*
3496                          * If this is a new directory and the label was
3497                          * transmuted when the inode was initialized
3498                          * set the transmute attribute on the directory
3499                          * and mark the inode.
3500                          *
3501                          * If there is a transmute attribute on the
3502                          * directory mark the inode.
3503                          */
3504                         if (isp->smk_flags & SMK_INODE_CHANGED) {
3505                                 isp->smk_flags &= ~SMK_INODE_CHANGED;
3506                                 rc = __vfs_setxattr(dp, inode,
3507                                         XATTR_NAME_SMACKTRANSMUTE,
3508                                         TRANS_TRUE, TRANS_TRUE_SIZE,
3509                                         0);
3510                         } else {
3511                                 rc = __vfs_getxattr(dp, inode,
3512                                         XATTR_NAME_SMACKTRANSMUTE, trattr,
3513                                         TRANS_TRUE_SIZE);
3514                                 if (rc >= 0 && strncmp(trattr, TRANS_TRUE,
3515                                                        TRANS_TRUE_SIZE) != 0)
3516                                         rc = -EINVAL;
3517                         }
3518                         if (rc >= 0)
3519                                 transflag = SMK_INODE_TRANSMUTE;
3520                 }
3521                 /*
3522                  * Don't let the exec or mmap label be "*" or "@".
3523                  */
3524                 skp = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp);
3525                 if (IS_ERR(skp) || skp == &smack_known_star ||
3526                     skp == &smack_known_web)
3527                         skp = NULL;
3528                 isp->smk_task = skp;
3529
3530                 skp = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp);
3531                 if (IS_ERR(skp) || skp == &smack_known_star ||
3532                     skp == &smack_known_web)
3533                         skp = NULL;
3534                 isp->smk_mmap = skp;
3535
3536                 dput(dp);
3537                 break;
3538         }
3539
3540         if (final == NULL)
3541                 isp->smk_inode = ckp;
3542         else
3543                 isp->smk_inode = final;
3544
3545         isp->smk_flags |= (SMK_INODE_INSTANT | transflag);
3546
3547 unlockandout:
3548         mutex_unlock(&isp->smk_lock);
3549         return;
3550 }
3551
3552 /**
3553  * smack_getprocattr - Smack process attribute access
3554  * @p: the object task
3555  * @name: the name of the attribute in /proc/.../attr
3556  * @value: where to put the result
3557  *
3558  * Places a copy of the task Smack into value
3559  *
3560  * Returns the length of the smack label or an error code
3561  */
3562 static int smack_getprocattr(struct task_struct *p, char *name, char **value)
3563 {
3564         struct smack_known *skp = smk_of_task_struct(p);
3565         char *cp;
3566         int slen;
3567
3568         if (strcmp(name, "current") != 0)
3569                 return -EINVAL;
3570
3571         cp = kstrdup(skp->smk_known, GFP_KERNEL);
3572         if (cp == NULL)
3573                 return -ENOMEM;
3574
3575         slen = strlen(cp);
3576         *value = cp;
3577         return slen;
3578 }
3579
3580 /**
3581  * smack_setprocattr - Smack process attribute setting
3582  * @name: the name of the attribute in /proc/.../attr
3583  * @value: the value to set
3584  * @size: the size of the value
3585  *
3586  * Sets the Smack value of the task. Only setting self
3587  * is permitted and only with privilege
3588  *
3589  * Returns the length of the smack label or an error code
3590  */
3591 static int smack_setprocattr(const char *name, void *value, size_t size)
3592 {
3593         struct task_smack *tsp = current_security();
3594         struct cred *new;
3595         struct smack_known *skp;
3596         struct smack_known_list_elem *sklep;
3597         int rc;
3598
3599         if (!smack_privileged(CAP_MAC_ADMIN) && list_empty(&tsp->smk_relabel))
3600                 return -EPERM;
3601
3602         if (value == NULL || size == 0 || size >= SMK_LONGLABEL)
3603                 return -EINVAL;
3604
3605         if (strcmp(name, "current") != 0)
3606                 return -EINVAL;
3607
3608         skp = smk_import_entry(value, size);
3609         if (IS_ERR(skp))
3610                 return PTR_ERR(skp);
3611
3612         /*
3613          * No process is ever allowed the web ("@") label
3614          * and the star ("*") label.
3615          */
3616         if (skp == &smack_known_web || skp == &smack_known_star)
3617                 return -EINVAL;
3618
3619         if (!smack_privileged(CAP_MAC_ADMIN)) {
3620                 rc = -EPERM;
3621                 list_for_each_entry(sklep, &tsp->smk_relabel, list)
3622                         if (sklep->smk_label == skp) {
3623                                 rc = 0;
3624                                 break;
3625                         }
3626                 if (rc)
3627                         return rc;
3628         }
3629
3630         new = prepare_creds();
3631         if (new == NULL)
3632                 return -ENOMEM;
3633
3634         tsp = new->security;
3635         tsp->smk_task = skp;
3636         /*
3637          * process can change its label only once
3638          */
3639         smk_destroy_label_list(&tsp->smk_relabel);
3640
3641         commit_creds(new);
3642         return size;
3643 }
3644
3645 /**
3646  * smack_unix_stream_connect - Smack access on UDS
3647  * @sock: one sock
3648  * @other: the other sock
3649  * @newsk: unused
3650  *
3651  * Return 0 if a subject with the smack of sock could access
3652  * an object with the smack of other, otherwise an error code
3653  */
3654 static int smack_unix_stream_connect(struct sock *sock,
3655                                      struct sock *other, struct sock *newsk)
3656 {
3657         struct smack_known *skp;
3658         struct smack_known *okp;
3659         struct socket_smack *ssp = sock->sk_security;
3660         struct socket_smack *osp = other->sk_security;
3661         struct socket_smack *nsp = newsk->sk_security;
3662         struct smk_audit_info ad;
3663         int rc = 0;
3664 #ifdef CONFIG_AUDIT
3665         struct lsm_network_audit net;
3666 #endif
3667
3668         if (!smack_privileged(CAP_MAC_OVERRIDE)) {
3669                 skp = ssp->smk_out;
3670                 okp = osp->smk_in;
3671 #ifdef CONFIG_AUDIT
3672                 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3673                 smk_ad_setfield_u_net_sk(&ad, other);
3674 #endif
3675                 rc = smk_access(skp, okp, MAY_WRITE, &ad);
3676                 rc = smk_bu_note("UDS connect", skp, okp, MAY_WRITE, rc);
3677                 if (rc == 0) {
3678                         okp = osp->smk_out;
3679                         skp = ssp->smk_in;
3680                         rc = smk_access(okp, skp, MAY_WRITE, &ad);
3681                         rc = smk_bu_note("UDS connect", okp, skp,
3682                                                 MAY_WRITE, rc);
3683                 }
3684         }
3685
3686         /*
3687          * Cross reference the peer labels for SO_PEERSEC.
3688          */
3689         if (rc == 0) {
3690                 nsp->smk_packet = ssp->smk_out;
3691                 ssp->smk_packet = osp->smk_out;
3692         }
3693
3694         return rc;
3695 }
3696
3697 /**
3698  * smack_unix_may_send - Smack access on UDS
3699  * @sock: one socket
3700  * @other: the other socket
3701  *
3702  * Return 0 if a subject with the smack of sock could access
3703  * an object with the smack of other, otherwise an error code
3704  */
3705 static int smack_unix_may_send(struct socket *sock, struct socket *other)
3706 {
3707         struct socket_smack *ssp = sock->sk->sk_security;
3708         struct socket_smack *osp = other->sk->sk_security;
3709         struct smk_audit_info ad;
3710         int rc;
3711
3712 #ifdef CONFIG_AUDIT
3713         struct lsm_network_audit net;
3714
3715         smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3716         smk_ad_setfield_u_net_sk(&ad, other->sk);
3717 #endif
3718
3719         if (smack_privileged(CAP_MAC_OVERRIDE))
3720                 return 0;
3721
3722         rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);
3723         rc = smk_bu_note("UDS send", ssp->smk_out, osp->smk_in, MAY_WRITE, rc);
3724         return rc;
3725 }
3726
3727 /**
3728  * smack_socket_sendmsg - Smack check based on destination host
3729  * @sock: the socket
3730  * @msg: the message
3731  * @size: the size of the message
3732  *
3733  * Return 0 if the current subject can write to the destination host.
3734  * For IPv4 this is only a question if the destination is a single label host.
3735  * For IPv6 this is a check against the label of the port.
3736  */
3737 static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
3738                                 int size)
3739 {
3740         struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;
3741 #if IS_ENABLED(CONFIG_IPV6)
3742         struct sockaddr_in6 *sap = (struct sockaddr_in6 *) msg->msg_name;
3743 #endif
3744 #ifdef SMACK_IPV6_SECMARK_LABELING
3745         struct socket_smack *ssp = sock->sk->sk_security;
3746         struct smack_known *rsp;
3747 #endif
3748         int rc = 0;
3749
3750         /*
3751          * Perfectly reasonable for this to be NULL
3752          */
3753         if (sip == NULL)
3754                 return 0;
3755
3756         switch (sock->sk->sk_family) {
3757         case AF_INET:
3758                 rc = smack_netlabel_send(sock->sk, sip);
3759                 break;
3760         case AF_INET6:
3761 #ifdef SMACK_IPV6_SECMARK_LABELING
3762                 rsp = smack_ipv6host_label(sap);
3763                 if (rsp != NULL)
3764                         rc = smk_ipv6_check(ssp->smk_out, rsp, sap,
3765                                                 SMK_CONNECTING);
3766 #endif
3767 #ifdef SMACK_IPV6_PORT_LABELING
3768                 rc = smk_ipv6_port_check(sock->sk, sap, SMK_SENDING);
3769 #endif
3770                 break;
3771         }
3772         return rc;
3773 }
3774
3775 /**
3776  * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat pair to smack
3777  * @sap: netlabel secattr
3778  * @ssp: socket security information
3779  *
3780  * Returns a pointer to a Smack label entry found on the label list.
3781  */
3782 static struct smack_known *smack_from_secattr(struct netlbl_lsm_secattr *sap,
3783                                                 struct socket_smack *ssp)
3784 {
3785         struct smack_known *skp;
3786         int found = 0;
3787         int acat;
3788         int kcat;
3789
3790         if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
3791                 /*
3792                  * Looks like a CIPSO packet.
3793                  * If there are flags but no level netlabel isn't
3794                  * behaving the way we expect it to.
3795                  *
3796                  * Look it up in the label table
3797                  * Without guidance regarding the smack value
3798                  * for the packet fall back on the network
3799                  * ambient value.
3800                  */
3801                 rcu_read_lock();
3802                 list_for_each_entry_rcu(skp, &smack_known_list, list) {
3803                         if (sap->attr.mls.lvl != skp->smk_netlabel.attr.mls.lvl)
3804                                 continue;
3805                         /*
3806                          * Compare the catsets. Use the netlbl APIs.
3807                          */
3808                         if ((sap->flags & NETLBL_SECATTR_MLS_CAT) == 0) {
3809                                 if ((skp->smk_netlabel.flags &
3810                                      NETLBL_SECATTR_MLS_CAT) == 0)
3811                                         found = 1;
3812                                 break;
3813                         }
3814                         for (acat = -1, kcat = -1; acat == kcat; ) {
3815                                 acat = netlbl_catmap_walk(sap->attr.mls.cat,
3816                                                           acat + 1);
3817                                 kcat = netlbl_catmap_walk(
3818                                         skp->smk_netlabel.attr.mls.cat,
3819                                         kcat + 1);
3820                                 if (acat < 0 || kcat < 0)
3821                                         break;
3822                         }
3823                         if (acat == kcat) {
3824                                 found = 1;
3825                                 break;
3826                         }
3827                 }
3828                 rcu_read_unlock();
3829
3830                 if (found)
3831                         return skp;
3832
3833                 if (ssp != NULL && ssp->smk_in == &smack_known_star)
3834                         return &smack_known_web;
3835                 return &smack_known_star;
3836         }
3837         if ((sap->flags & NETLBL_SECATTR_SECID) != 0)
3838                 /*
3839                  * Looks like a fallback, which gives us a secid.
3840                  */
3841                 return smack_from_secid(sap->attr.secid);
3842         /*
3843          * Without guidance regarding the smack value
3844          * for the packet fall back on the network
3845          * ambient value.
3846          */
3847         return smack_net_ambient;
3848 }
3849
3850 #if IS_ENABLED(CONFIG_IPV6)
3851 static int smk_skb_to_addr_ipv6(struct sk_buff *skb, struct sockaddr_in6 *sip)
3852 {
3853         u8 nexthdr;
3854         int offset;
3855         int proto = -EINVAL;
3856         struct ipv6hdr _ipv6h;
3857         struct ipv6hdr *ip6;
3858         __be16 frag_off;
3859         struct tcphdr _tcph, *th;
3860         struct udphdr _udph, *uh;
3861         struct dccp_hdr _dccph, *dh;
3862
3863         sip->sin6_port = 0;
3864
3865         offset = skb_network_offset(skb);
3866         ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3867         if (ip6 == NULL)
3868                 return -EINVAL;
3869         sip->sin6_addr = ip6->saddr;
3870
3871         nexthdr = ip6->nexthdr;
3872         offset += sizeof(_ipv6h);
3873         offset = ipv6_skip_exthdr(skb, offset, &nexthdr, &frag_off);
3874         if (offset < 0)
3875                 return -EINVAL;
3876
3877         proto = nexthdr;
3878         switch (proto) {
3879         case IPPROTO_TCP:
3880                 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3881                 if (th != NULL)
3882                         sip->sin6_port = th->source;
3883                 break;
3884         case IPPROTO_UDP:
3885         case IPPROTO_UDPLITE:
3886                 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3887                 if (uh != NULL)
3888                         sip->sin6_port = uh->source;
3889                 break;
3890         case IPPROTO_DCCP:
3891                 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3892                 if (dh != NULL)
3893                         sip->sin6_port = dh->dccph_sport;
3894                 break;
3895         }
3896         return proto;
3897 }
3898 #endif /* CONFIG_IPV6 */
3899
3900 /**
3901  * smack_socket_sock_rcv_skb - Smack packet delivery access check
3902  * @sk: socket
3903  * @skb: packet
3904  *
3905  * Returns 0 if the packet should be delivered, an error code otherwise
3906  */
3907 static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
3908 {
3909         struct netlbl_lsm_secattr secattr;
3910         struct socket_smack *ssp = sk->sk_security;
3911         struct smack_known *skp = NULL;
3912         int rc = 0;
3913         struct smk_audit_info ad;
3914         u16 family = sk->sk_family;
3915 #ifdef CONFIG_AUDIT
3916         struct lsm_network_audit net;
3917 #endif
3918 #if IS_ENABLED(CONFIG_IPV6)
3919         struct sockaddr_in6 sadd;
3920         int proto;
3921
3922         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
3923                 family = PF_INET;
3924 #endif /* CONFIG_IPV6 */
3925
3926         switch (family) {
3927         case PF_INET:
3928 #ifdef CONFIG_SECURITY_SMACK_NETFILTER
3929                 /*
3930                  * If there is a secmark use it rather than the CIPSO label.
3931                  * If there is no secmark fall back to CIPSO.
3932                  * The secmark is assumed to reflect policy better.
3933                  */
3934                 if (skb && skb->secmark != 0) {
3935                         skp = smack_from_secid(skb->secmark);
3936                         goto access_check;
3937                 }
3938 #endif /* CONFIG_SECURITY_SMACK_NETFILTER */
3939                 /*
3940                  * Translate what netlabel gave us.
3941                  */
3942                 netlbl_secattr_init(&secattr);
3943
3944                 rc = netlbl_skbuff_getattr(skb, family, &secattr);
3945                 if (rc == 0)
3946                         skp = smack_from_secattr(&secattr, ssp);
3947                 else
3948                         skp = smack_net_ambient;
3949
3950                 netlbl_secattr_destroy(&secattr);
3951
3952 #ifdef CONFIG_SECURITY_SMACK_NETFILTER
3953 access_check:
3954 #endif
3955 #ifdef CONFIG_AUDIT
3956                 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3957                 ad.a.u.net->family = family;
3958                 ad.a.u.net->netif = skb->skb_iif;
3959                 ipv4_skb_to_auditdata(skb, &ad.a, NULL);
3960 #endif
3961                 /*
3962                  * Receiving a packet requires that the other end
3963                  * be able to write here. Read access is not required.
3964                  * This is the simplist possible security model
3965                  * for networking.
3966                  */
3967                 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
3968                 rc = smk_bu_note("IPv4 delivery", skp, ssp->smk_in,
3969                                         MAY_WRITE, rc);
3970                 if (rc != 0)
3971                         netlbl_skbuff_err(skb, family, rc, 0);
3972                 break;
3973 #if IS_ENABLED(CONFIG_IPV6)
3974         case PF_INET6:
3975                 proto = smk_skb_to_addr_ipv6(skb, &sadd);
3976                 if (proto != IPPROTO_UDP && proto != IPPROTO_UDPLITE &&
3977                     proto != IPPROTO_TCP && proto != IPPROTO_DCCP)
3978                         break;
3979 #ifdef SMACK_IPV6_SECMARK_LABELING
3980                 if (skb && skb->secmark != 0)
3981                         skp = smack_from_secid(skb->secmark);
3982                 else
3983                         skp = smack_ipv6host_label(&sadd);
3984                 if (skp == NULL)
3985                         skp = smack_net_ambient;
3986 #ifdef CONFIG_AUDIT
3987                 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3988                 ad.a.u.net->family = family;
3989                 ad.a.u.net->netif = skb->skb_iif;
3990                 ipv6_skb_to_auditdata(skb, &ad.a, NULL);
3991 #endif /* CONFIG_AUDIT */
3992                 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
3993                 rc = smk_bu_note("IPv6 delivery", skp, ssp->smk_in,
3994                                         MAY_WRITE, rc);
3995 #endif /* SMACK_IPV6_SECMARK_LABELING */
3996 #ifdef SMACK_IPV6_PORT_LABELING
3997                 rc = smk_ipv6_port_check(sk, &sadd, SMK_RECEIVING);
3998 #endif /* SMACK_IPV6_PORT_LABELING */
3999                 if (rc != 0)
4000                         icmpv6_send(skb, ICMPV6_DEST_UNREACH,
4001                                         ICMPV6_ADM_PROHIBITED, 0);
4002                 break;
4003 #endif /* CONFIG_IPV6 */
4004         }
4005
4006         return rc;
4007 }
4008
4009 /**
4010  * smack_socket_getpeersec_stream - pull in packet label
4011  * @sock: the socket
4012  * @optval: user's destination
4013  * @optlen: size thereof
4014  * @len: max thereof
4015  *
4016  * returns zero on success, an error code otherwise
4017  */
4018 static int smack_socket_getpeersec_stream(struct socket *sock,
4019                                           char __user *optval,
4020                                           int __user *optlen, unsigned len)
4021 {
4022         struct socket_smack *ssp;
4023         char *rcp = "";
4024         int slen = 1;
4025         int rc = 0;
4026
4027         ssp = sock->sk->sk_security;
4028         if (ssp->smk_packet != NULL) {
4029                 rcp = ssp->smk_packet->smk_known;
4030                 slen = strlen(rcp) + 1;
4031         }
4032
4033         if (slen > len)
4034                 rc = -ERANGE;
4035         else if (copy_to_user(optval, rcp, slen) != 0)
4036                 rc = -EFAULT;
4037
4038         if (put_user(slen, optlen) != 0)
4039                 rc = -EFAULT;
4040
4041         return rc;
4042 }
4043
4044
4045 /**
4046  * smack_socket_getpeersec_dgram - pull in packet label
4047  * @sock: the peer socket
4048  * @skb: packet data
4049  * @secid: pointer to where to put the secid of the packet
4050  *
4051  * Sets the netlabel socket state on sk from parent
4052  */
4053 static int smack_socket_getpeersec_dgram(struct socket *sock,
4054                                          struct sk_buff *skb, u32 *secid)
4055
4056 {
4057         struct netlbl_lsm_secattr secattr;
4058         struct socket_smack *ssp = NULL;
4059         struct smack_known *skp;
4060         int family = PF_UNSPEC;
4061         u32 s = 0;      /* 0 is the invalid secid */
4062         int rc;
4063
4064         if (skb != NULL) {
4065                 if (skb->protocol == htons(ETH_P_IP))
4066                         family = PF_INET;
4067 #if IS_ENABLED(CONFIG_IPV6)
4068                 else if (skb->protocol == htons(ETH_P_IPV6))
4069                         family = PF_INET6;
4070 #endif /* CONFIG_IPV6 */
4071         }
4072         if (family == PF_UNSPEC && sock != NULL)
4073                 family = sock->sk->sk_family;
4074
4075         switch (family) {
4076         case PF_UNIX:
4077                 ssp = sock->sk->sk_security;
4078                 s = ssp->smk_out->smk_secid;
4079                 break;
4080         case PF_INET:
4081 #ifdef CONFIG_SECURITY_SMACK_NETFILTER
4082                 s = skb->secmark;
4083                 if (s != 0)
4084                         break;
4085 #endif
4086                 /*
4087                  * Translate what netlabel gave us.
4088                  */
4089                 if (sock != NULL && sock->sk != NULL)
4090                         ssp = sock->sk->sk_security;
4091                 netlbl_secattr_init(&secattr);
4092                 rc = netlbl_skbuff_getattr(skb, family, &secattr);
4093                 if (rc == 0) {
4094                         skp = smack_from_secattr(&secattr, ssp);
4095                         s = skp->smk_secid;
4096                 }
4097                 netlbl_secattr_destroy(&secattr);
4098                 break;
4099         case PF_INET6:
4100 #ifdef SMACK_IPV6_SECMARK_LABELING
4101                 s = skb->secmark;
4102 #endif
4103                 break;
4104         }
4105         *secid = s;
4106         if (s == 0)
4107                 return -EINVAL;
4108         return 0;
4109 }
4110
4111 /**
4112  * smack_sock_graft - Initialize a newly created socket with an existing sock
4113  * @sk: child sock
4114  * @parent: parent socket
4115  *
4116  * Set the smk_{in,out} state of an existing sock based on the process that
4117  * is creating the new socket.
4118  */
4119 static void smack_sock_graft(struct sock *sk, struct socket *parent)
4120 {
4121         struct socket_smack *ssp;
4122         struct smack_known *skp = smk_of_current();
4123
4124         if (sk == NULL ||
4125             (sk->sk_family != PF_INET && sk->sk_family != PF_INET6))
4126                 return;
4127
4128         ssp = sk->sk_security;
4129         ssp->smk_in = skp;
4130         ssp->smk_out = skp;
4131         /* cssp->smk_packet is already set in smack_inet_csk_clone() */
4132 }
4133
4134 /**
4135  * smack_inet_conn_request - Smack access check on connect
4136  * @sk: socket involved
4137  * @skb: packet
4138  * @req: unused
4139  *
4140  * Returns 0 if a task with the packet label could write to
4141  * the socket, otherwise an error code
4142  */
4143 static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4144                                    struct request_sock *req)
4145 {
4146         u16 family = sk->sk_family;
4147         struct smack_known *skp;
4148         struct socket_smack *ssp = sk->sk_security;
4149         struct netlbl_lsm_secattr secattr;
4150         struct sockaddr_in addr;
4151         struct iphdr *hdr;
4152         struct smack_known *hskp;
4153         int rc;
4154         struct smk_audit_info ad;
4155 #ifdef CONFIG_AUDIT
4156         struct lsm_network_audit net;
4157 #endif
4158
4159 #if IS_ENABLED(CONFIG_IPV6)
4160         if (family == PF_INET6) {
4161                 /*
4162                  * Handle mapped IPv4 pa