Smack: Transmute labels on specified directories
[linux-2.6.git] / security / smack / smackfs.c
1 /*
2  * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
3  *
4  *      This program is free software; you can redistribute it and/or modify
5  *      it under the terms of the GNU General Public License as published by
6  *      the Free Software Foundation, version 2.
7  *
8  * Authors:
9  *      Casey Schaufler <casey@schaufler-ca.com>
10  *      Ahmed S. Darwish <darwish.07@gmail.com>
11  *
12  * Special thanks to the authors of selinuxfs.
13  *
14  *      Karl MacMillan <kmacmillan@tresys.com>
15  *      James Morris <jmorris@redhat.com>
16  *
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/vmalloc.h>
21 #include <linux/security.h>
22 #include <linux/mutex.h>
23 #include <linux/slab.h>
24 #include <net/net_namespace.h>
25 #include <net/netlabel.h>
26 #include <net/cipso_ipv4.h>
27 #include <linux/seq_file.h>
28 #include <linux/ctype.h>
29 #include <linux/audit.h>
30 #include "smack.h"
31
32 /*
33  * smackfs pseudo filesystem.
34  */
35
36 enum smk_inos {
37         SMK_ROOT_INO    = 2,
38         SMK_LOAD        = 3,    /* load policy */
39         SMK_CIPSO       = 4,    /* load label -> CIPSO mapping */
40         SMK_DOI         = 5,    /* CIPSO DOI */
41         SMK_DIRECT      = 6,    /* CIPSO level indicating direct label */
42         SMK_AMBIENT     = 7,    /* internet ambient label */
43         SMK_NETLBLADDR  = 8,    /* single label hosts */
44         SMK_ONLYCAP     = 9,    /* the only "capable" label */
45         SMK_LOGGING     = 10,   /* logging */
46 };
47
48 /*
49  * List locks
50  */
51 static DEFINE_MUTEX(smack_list_lock);
52 static DEFINE_MUTEX(smack_cipso_lock);
53 static DEFINE_MUTEX(smack_ambient_lock);
54 static DEFINE_MUTEX(smk_netlbladdr_lock);
55
56 /*
57  * This is the "ambient" label for network traffic.
58  * If it isn't somehow marked, use this.
59  * It can be reset via smackfs/ambient
60  */
61 char *smack_net_ambient = smack_known_floor.smk_known;
62
63 /*
64  * This is the level in a CIPSO header that indicates a
65  * smack label is contained directly in the category set.
66  * It can be reset via smackfs/direct
67  */
68 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
69
70 /*
71  * Unless a process is running with this label even
72  * having CAP_MAC_OVERRIDE isn't enough to grant
73  * privilege to violate MAC policy. If no label is
74  * designated (the NULL case) capabilities apply to
75  * everyone. It is expected that the hat (^) label
76  * will be used if any label is used.
77  */
78 char *smack_onlycap;
79
80 /*
81  * Certain IP addresses may be designated as single label hosts.
82  * Packets are sent there unlabeled, but only from tasks that
83  * can write to the specified label.
84  */
85
86 LIST_HEAD(smk_netlbladdr_list);
87 LIST_HEAD(smack_rule_list);
88
89 static int smk_cipso_doi_value = SMACK_CIPSO_DOI_DEFAULT;
90
91 const char *smack_cipso_option = SMACK_CIPSO_OPTION;
92
93
94 #define SEQ_READ_FINISHED       1
95
96 /*
97  * Values for parsing cipso rules
98  * SMK_DIGITLEN: Length of a digit field in a rule.
99  * SMK_CIPSOMIN: Minimum possible cipso rule length.
100  * SMK_CIPSOMAX: Maximum possible cipso rule length.
101  */
102 #define SMK_DIGITLEN 4
103 #define SMK_CIPSOMIN (SMK_LABELLEN + 2 * SMK_DIGITLEN)
104 #define SMK_CIPSOMAX (SMK_CIPSOMIN + SMACK_CIPSO_MAXCATNUM * SMK_DIGITLEN)
105
106 /*
107  * Values for parsing MAC rules
108  * SMK_ACCESS: Maximum possible combination of access permissions
109  * SMK_ACCESSLEN: Maximum length for a rule access field
110  * SMK_LOADLEN: Smack rule length
111  */
112 #define SMK_OACCESS     "rwxa"
113 #define SMK_ACCESS      "rwxat"
114 #define SMK_OACCESSLEN  (sizeof(SMK_OACCESS) - 1)
115 #define SMK_ACCESSLEN   (sizeof(SMK_ACCESS) - 1)
116 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
117 #define SMK_LOADLEN     (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSLEN)
118
119 /**
120  * smk_netlabel_audit_set - fill a netlbl_audit struct
121  * @nap: structure to fill
122  */
123 static void smk_netlabel_audit_set(struct netlbl_audit *nap)
124 {
125         nap->loginuid = audit_get_loginuid(current);
126         nap->sessionid = audit_get_sessionid(current);
127         nap->secid = smack_to_secid(smk_of_current());
128 }
129
130 /*
131  * Values for parsing single label host rules
132  * "1.2.3.4 X"
133  * "192.168.138.129/32 abcdefghijklmnopqrstuvw"
134  */
135 #define SMK_NETLBLADDRMIN       9
136 #define SMK_NETLBLADDRMAX       42
137
138 /*
139  * Seq_file read operations for /smack/load
140  */
141
142 static void *load_seq_start(struct seq_file *s, loff_t *pos)
143 {
144         if (*pos == SEQ_READ_FINISHED)
145                 return NULL;
146         if (list_empty(&smack_rule_list))
147                 return NULL;
148         return smack_rule_list.next;
149 }
150
151 static void *load_seq_next(struct seq_file *s, void *v, loff_t *pos)
152 {
153         struct list_head *list = v;
154
155         if (list_is_last(list, &smack_rule_list)) {
156                 *pos = SEQ_READ_FINISHED;
157                 return NULL;
158         }
159         return list->next;
160 }
161
162 static int load_seq_show(struct seq_file *s, void *v)
163 {
164         struct list_head *list = v;
165         struct smack_rule *srp =
166                  list_entry(list, struct smack_rule, list);
167
168         seq_printf(s, "%s %s", (char *)srp->smk_subject,
169                    (char *)srp->smk_object);
170
171         seq_putc(s, ' ');
172
173         if (srp->smk_access & MAY_READ)
174                 seq_putc(s, 'r');
175         if (srp->smk_access & MAY_WRITE)
176                 seq_putc(s, 'w');
177         if (srp->smk_access & MAY_EXEC)
178                 seq_putc(s, 'x');
179         if (srp->smk_access & MAY_APPEND)
180                 seq_putc(s, 'a');
181         if (srp->smk_access & MAY_TRANSMUTE)
182                 seq_putc(s, 't');
183         if (srp->smk_access == 0)
184                 seq_putc(s, '-');
185
186         seq_putc(s, '\n');
187
188         return 0;
189 }
190
191 static void load_seq_stop(struct seq_file *s, void *v)
192 {
193         /* No-op */
194 }
195
196 static const struct seq_operations load_seq_ops = {
197         .start = load_seq_start,
198         .next  = load_seq_next,
199         .show  = load_seq_show,
200         .stop  = load_seq_stop,
201 };
202
203 /**
204  * smk_open_load - open() for /smack/load
205  * @inode: inode structure representing file
206  * @file: "load" file pointer
207  *
208  * For reading, use load_seq_* seq_file reading operations.
209  */
210 static int smk_open_load(struct inode *inode, struct file *file)
211 {
212         return seq_open(file, &load_seq_ops);
213 }
214
215 /**
216  * smk_set_access - add a rule to the rule list
217  * @srp: the new rule to add
218  *
219  * Looks through the current subject/object/access list for
220  * the subject/object pair and replaces the access that was
221  * there. If the pair isn't found add it with the specified
222  * access.
223  *
224  * Returns 0 if nothing goes wrong or -ENOMEM if it fails
225  * during the allocation of the new pair to add.
226  */
227 static int smk_set_access(struct smack_rule *srp)
228 {
229         struct smack_rule *sp;
230         int ret = 0;
231         int found;
232         mutex_lock(&smack_list_lock);
233
234         found = 0;
235         list_for_each_entry_rcu(sp, &smack_rule_list, list) {
236                 if (sp->smk_subject == srp->smk_subject &&
237                     sp->smk_object == srp->smk_object) {
238                         found = 1;
239                         sp->smk_access = srp->smk_access;
240                         break;
241                 }
242         }
243         if (found == 0)
244                 list_add_rcu(&srp->list, &smack_rule_list);
245
246         mutex_unlock(&smack_list_lock);
247
248         return ret;
249 }
250
251 /**
252  * smk_write_load - write() for /smack/load
253  * @file: file pointer, not actually used
254  * @buf: where to get the data from
255  * @count: bytes sent
256  * @ppos: where to start - must be 0
257  *
258  * Get one smack access rule from above.
259  * The format is exactly:
260  *     char subject[SMK_LABELLEN]
261  *     char object[SMK_LABELLEN]
262  *     char access[SMK_ACCESSLEN]
263  *
264  * writes must be SMK_LABELLEN+SMK_LABELLEN+SMK_ACCESSLEN bytes.
265  */
266 static ssize_t smk_write_load(struct file *file, const char __user *buf,
267                               size_t count, loff_t *ppos)
268 {
269         struct smack_rule *rule;
270         char *data;
271         int rc = -EINVAL;
272
273         /*
274          * Must have privilege.
275          * No partial writes.
276          * Enough data must be present.
277          */
278         if (!capable(CAP_MAC_ADMIN))
279                 return -EPERM;
280
281         if (*ppos != 0)
282                 return -EINVAL;
283         /*
284          * Minor hack for backward compatability
285          */
286         if (count < (SMK_OLOADLEN) || count > SMK_LOADLEN)
287                 return -EINVAL;
288
289         data = kzalloc(SMK_LOADLEN, GFP_KERNEL);
290         if (data == NULL)
291                 return -ENOMEM;
292
293         if (copy_from_user(data, buf, count) != 0) {
294                 rc = -EFAULT;
295                 goto out;
296         }
297
298         /*
299          * More on the minor hack for backward compatability
300          */
301         if (count == (SMK_OLOADLEN))
302                 data[SMK_OLOADLEN] = '-';
303
304         rule = kzalloc(sizeof(*rule), GFP_KERNEL);
305         if (rule == NULL) {
306                 rc = -ENOMEM;
307                 goto out;
308         }
309
310         rule->smk_subject = smk_import(data, 0);
311         if (rule->smk_subject == NULL)
312                 goto out_free_rule;
313
314         rule->smk_object = smk_import(data + SMK_LABELLEN, 0);
315         if (rule->smk_object == NULL)
316                 goto out_free_rule;
317
318         rule->smk_access = 0;
319
320         switch (data[SMK_LABELLEN + SMK_LABELLEN]) {
321         case '-':
322                 break;
323         case 'r':
324         case 'R':
325                 rule->smk_access |= MAY_READ;
326                 break;
327         default:
328                 goto out_free_rule;
329         }
330
331         switch (data[SMK_LABELLEN + SMK_LABELLEN + 1]) {
332         case '-':
333                 break;
334         case 'w':
335         case 'W':
336                 rule->smk_access |= MAY_WRITE;
337                 break;
338         default:
339                 goto out_free_rule;
340         }
341
342         switch (data[SMK_LABELLEN + SMK_LABELLEN + 2]) {
343         case '-':
344                 break;
345         case 'x':
346         case 'X':
347                 rule->smk_access |= MAY_EXEC;
348                 break;
349         default:
350                 goto out_free_rule;
351         }
352
353         switch (data[SMK_LABELLEN + SMK_LABELLEN + 3]) {
354         case '-':
355                 break;
356         case 'a':
357         case 'A':
358                 rule->smk_access |= MAY_APPEND;
359                 break;
360         default:
361                 goto out_free_rule;
362         }
363
364         switch (data[SMK_LABELLEN + SMK_LABELLEN + 4]) {
365         case '-':
366                 break;
367         case 't':
368         case 'T':
369                 rule->smk_access |= MAY_TRANSMUTE;
370                 break;
371         default:
372                 goto out_free_rule;
373         }
374
375         rc = smk_set_access(rule);
376
377         if (!rc)
378                 rc = count;
379         goto out;
380
381 out_free_rule:
382         kfree(rule);
383 out:
384         kfree(data);
385         return rc;
386 }
387
388 static const struct file_operations smk_load_ops = {
389         .open           = smk_open_load,
390         .read           = seq_read,
391         .llseek         = seq_lseek,
392         .write          = smk_write_load,
393         .release        = seq_release,
394 };
395
396 /**
397  * smk_cipso_doi - initialize the CIPSO domain
398  */
399 static void smk_cipso_doi(void)
400 {
401         int rc;
402         struct cipso_v4_doi *doip;
403         struct netlbl_audit nai;
404
405         smk_netlabel_audit_set(&nai);
406
407         rc = netlbl_cfg_map_del(NULL, PF_INET, NULL, NULL, &nai);
408         if (rc != 0)
409                 printk(KERN_WARNING "%s:%d remove rc = %d\n",
410                        __func__, __LINE__, rc);
411
412         doip = kmalloc(sizeof(struct cipso_v4_doi), GFP_KERNEL);
413         if (doip == NULL)
414                 panic("smack:  Failed to initialize cipso DOI.\n");
415         doip->map.std = NULL;
416         doip->doi = smk_cipso_doi_value;
417         doip->type = CIPSO_V4_MAP_PASS;
418         doip->tags[0] = CIPSO_V4_TAG_RBITMAP;
419         for (rc = 1; rc < CIPSO_V4_TAG_MAXCNT; rc++)
420                 doip->tags[rc] = CIPSO_V4_TAG_INVALID;
421
422         rc = netlbl_cfg_cipsov4_add(doip, &nai);
423         if (rc != 0) {
424                 printk(KERN_WARNING "%s:%d cipso add rc = %d\n",
425                        __func__, __LINE__, rc);
426                 kfree(doip);
427                 return;
428         }
429         rc = netlbl_cfg_cipsov4_map_add(doip->doi, NULL, NULL, NULL, &nai);
430         if (rc != 0) {
431                 printk(KERN_WARNING "%s:%d map add rc = %d\n",
432                        __func__, __LINE__, rc);
433                 kfree(doip);
434                 return;
435         }
436 }
437
438 /**
439  * smk_unlbl_ambient - initialize the unlabeled domain
440  * @oldambient: previous domain string
441  */
442 static void smk_unlbl_ambient(char *oldambient)
443 {
444         int rc;
445         struct netlbl_audit nai;
446
447         smk_netlabel_audit_set(&nai);
448
449         if (oldambient != NULL) {
450                 rc = netlbl_cfg_map_del(oldambient, PF_INET, NULL, NULL, &nai);
451                 if (rc != 0)
452                         printk(KERN_WARNING "%s:%d remove rc = %d\n",
453                                __func__, __LINE__, rc);
454         }
455
456         rc = netlbl_cfg_unlbl_map_add(smack_net_ambient, PF_INET,
457                                       NULL, NULL, &nai);
458         if (rc != 0)
459                 printk(KERN_WARNING "%s:%d add rc = %d\n",
460                        __func__, __LINE__, rc);
461 }
462
463 /*
464  * Seq_file read operations for /smack/cipso
465  */
466
467 static void *cipso_seq_start(struct seq_file *s, loff_t *pos)
468 {
469         if (*pos == SEQ_READ_FINISHED)
470                 return NULL;
471         if (list_empty(&smack_known_list))
472                 return NULL;
473
474         return smack_known_list.next;
475 }
476
477 static void *cipso_seq_next(struct seq_file *s, void *v, loff_t *pos)
478 {
479         struct list_head  *list = v;
480
481         /*
482          * labels with no associated cipso value wont be printed
483          * in cipso_seq_show
484          */
485         if (list_is_last(list, &smack_known_list)) {
486                 *pos = SEQ_READ_FINISHED;
487                 return NULL;
488         }
489
490         return list->next;
491 }
492
493 /*
494  * Print cipso labels in format:
495  * label level[/cat[,cat]]
496  */
497 static int cipso_seq_show(struct seq_file *s, void *v)
498 {
499         struct list_head  *list = v;
500         struct smack_known *skp =
501                  list_entry(list, struct smack_known, list);
502         struct smack_cipso *scp = skp->smk_cipso;
503         char *cbp;
504         char sep = '/';
505         int cat = 1;
506         int i;
507         unsigned char m;
508
509         if (scp == NULL)
510                 return 0;
511
512         seq_printf(s, "%s %3d", (char *)&skp->smk_known, scp->smk_level);
513
514         cbp = scp->smk_catset;
515         for (i = 0; i < SMK_LABELLEN; i++)
516                 for (m = 0x80; m != 0; m >>= 1) {
517                         if (m & cbp[i]) {
518                                 seq_printf(s, "%c%d", sep, cat);
519                                 sep = ',';
520                         }
521                         cat++;
522                 }
523
524         seq_putc(s, '\n');
525
526         return 0;
527 }
528
529 static void cipso_seq_stop(struct seq_file *s, void *v)
530 {
531         /* No-op */
532 }
533
534 static const struct seq_operations cipso_seq_ops = {
535         .start = cipso_seq_start,
536         .stop  = cipso_seq_stop,
537         .next  = cipso_seq_next,
538         .show  = cipso_seq_show,
539 };
540
541 /**
542  * smk_open_cipso - open() for /smack/cipso
543  * @inode: inode structure representing file
544  * @file: "cipso" file pointer
545  *
546  * Connect our cipso_seq_* operations with /smack/cipso
547  * file_operations
548  */
549 static int smk_open_cipso(struct inode *inode, struct file *file)
550 {
551         return seq_open(file, &cipso_seq_ops);
552 }
553
554 /**
555  * smk_write_cipso - write() for /smack/cipso
556  * @file: file pointer, not actually used
557  * @buf: where to get the data from
558  * @count: bytes sent
559  * @ppos: where to start
560  *
561  * Accepts only one cipso rule per write call.
562  * Returns number of bytes written or error code, as appropriate
563  */
564 static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
565                                size_t count, loff_t *ppos)
566 {
567         struct smack_known *skp;
568         struct smack_cipso *scp = NULL;
569         char mapcatset[SMK_LABELLEN];
570         int maplevel;
571         int cat;
572         int catlen;
573         ssize_t rc = -EINVAL;
574         char *data = NULL;
575         char *rule;
576         int ret;
577         int i;
578
579         /*
580          * Must have privilege.
581          * No partial writes.
582          * Enough data must be present.
583          */
584         if (!capable(CAP_MAC_ADMIN))
585                 return -EPERM;
586         if (*ppos != 0)
587                 return -EINVAL;
588         if (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX)
589                 return -EINVAL;
590
591         data = kzalloc(count + 1, GFP_KERNEL);
592         if (data == NULL)
593                 return -ENOMEM;
594
595         if (copy_from_user(data, buf, count) != 0) {
596                 rc = -EFAULT;
597                 goto unlockedout;
598         }
599
600         /* labels cannot begin with a '-' */
601         if (data[0] == '-') {
602                 rc = -EINVAL;
603                 goto unlockedout;
604         }
605         data[count] = '\0';
606         rule = data;
607         /*
608          * Only allow one writer at a time. Writes should be
609          * quite rare and small in any case.
610          */
611         mutex_lock(&smack_cipso_lock);
612
613         skp = smk_import_entry(rule, 0);
614         if (skp == NULL)
615                 goto out;
616
617         rule += SMK_LABELLEN;
618         ret = sscanf(rule, "%d", &maplevel);
619         if (ret != 1 || maplevel > SMACK_CIPSO_MAXLEVEL)
620                 goto out;
621
622         rule += SMK_DIGITLEN;
623         ret = sscanf(rule, "%d", &catlen);
624         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
625                 goto out;
626
627         if (count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
628                 goto out;
629
630         memset(mapcatset, 0, sizeof(mapcatset));
631
632         for (i = 0; i < catlen; i++) {
633                 rule += SMK_DIGITLEN;
634                 ret = sscanf(rule, "%d", &cat);
635                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATVAL)
636                         goto out;
637
638                 smack_catset_bit(cat, mapcatset);
639         }
640
641         if (skp->smk_cipso == NULL) {
642                 scp = kzalloc(sizeof(struct smack_cipso), GFP_KERNEL);
643                 if (scp == NULL) {
644                         rc = -ENOMEM;
645                         goto out;
646                 }
647         }
648
649         spin_lock_bh(&skp->smk_cipsolock);
650
651         if (scp == NULL)
652                 scp = skp->smk_cipso;
653         else
654                 skp->smk_cipso = scp;
655
656         scp->smk_level = maplevel;
657         memcpy(scp->smk_catset, mapcatset, sizeof(mapcatset));
658
659         spin_unlock_bh(&skp->smk_cipsolock);
660
661         rc = count;
662 out:
663         mutex_unlock(&smack_cipso_lock);
664 unlockedout:
665         kfree(data);
666         return rc;
667 }
668
669 static const struct file_operations smk_cipso_ops = {
670         .open           = smk_open_cipso,
671         .read           = seq_read,
672         .llseek         = seq_lseek,
673         .write          = smk_write_cipso,
674         .release        = seq_release,
675 };
676
677 /*
678  * Seq_file read operations for /smack/netlabel
679  */
680
681 static void *netlbladdr_seq_start(struct seq_file *s, loff_t *pos)
682 {
683         if (*pos == SEQ_READ_FINISHED)
684                 return NULL;
685         if (list_empty(&smk_netlbladdr_list))
686                 return NULL;
687         return smk_netlbladdr_list.next;
688 }
689
690 static void *netlbladdr_seq_next(struct seq_file *s, void *v, loff_t *pos)
691 {
692         struct list_head *list = v;
693
694         if (list_is_last(list, &smk_netlbladdr_list)) {
695                 *pos = SEQ_READ_FINISHED;
696                 return NULL;
697         }
698
699         return list->next;
700 }
701 #define BEBITS  (sizeof(__be32) * 8)
702
703 /*
704  * Print host/label pairs
705  */
706 static int netlbladdr_seq_show(struct seq_file *s, void *v)
707 {
708         struct list_head *list = v;
709         struct smk_netlbladdr *skp =
710                          list_entry(list, struct smk_netlbladdr, list);
711         unsigned char *hp = (char *) &skp->smk_host.sin_addr.s_addr;
712         int maskn;
713         u32 temp_mask = be32_to_cpu(skp->smk_mask.s_addr);
714
715         for (maskn = 0; temp_mask; temp_mask <<= 1, maskn++);
716
717         seq_printf(s, "%u.%u.%u.%u/%d %s\n",
718                 hp[0], hp[1], hp[2], hp[3], maskn, skp->smk_label);
719
720         return 0;
721 }
722
723 static void netlbladdr_seq_stop(struct seq_file *s, void *v)
724 {
725         /* No-op */
726 }
727
728 static const struct seq_operations netlbladdr_seq_ops = {
729         .start = netlbladdr_seq_start,
730         .stop  = netlbladdr_seq_stop,
731         .next  = netlbladdr_seq_next,
732         .show  = netlbladdr_seq_show,
733 };
734
735 /**
736  * smk_open_netlbladdr - open() for /smack/netlabel
737  * @inode: inode structure representing file
738  * @file: "netlabel" file pointer
739  *
740  * Connect our netlbladdr_seq_* operations with /smack/netlabel
741  * file_operations
742  */
743 static int smk_open_netlbladdr(struct inode *inode, struct file *file)
744 {
745         return seq_open(file, &netlbladdr_seq_ops);
746 }
747
748 /**
749  * smk_netlbladdr_insert
750  * @new : netlabel to insert
751  *
752  * This helper insert netlabel in the smack_netlbladdrs list
753  * sorted by netmask length (longest to smallest)
754  * locked by &smk_netlbladdr_lock in smk_write_netlbladdr
755  *
756  */
757 static void smk_netlbladdr_insert(struct smk_netlbladdr *new)
758 {
759         struct smk_netlbladdr *m, *m_next;
760
761         if (list_empty(&smk_netlbladdr_list)) {
762                 list_add_rcu(&new->list, &smk_netlbladdr_list);
763                 return;
764         }
765
766         m = list_entry_rcu(smk_netlbladdr_list.next,
767                            struct smk_netlbladdr, list);
768
769         /* the comparison '>' is a bit hacky, but works */
770         if (new->smk_mask.s_addr > m->smk_mask.s_addr) {
771                 list_add_rcu(&new->list, &smk_netlbladdr_list);
772                 return;
773         }
774
775         list_for_each_entry_rcu(m, &smk_netlbladdr_list, list) {
776                 if (list_is_last(&m->list, &smk_netlbladdr_list)) {
777                         list_add_rcu(&new->list, &m->list);
778                         return;
779                 }
780                 m_next = list_entry_rcu(m->list.next,
781                                         struct smk_netlbladdr, list);
782                 if (new->smk_mask.s_addr > m_next->smk_mask.s_addr) {
783                         list_add_rcu(&new->list, &m->list);
784                         return;
785                 }
786         }
787 }
788
789
790 /**
791  * smk_write_netlbladdr - write() for /smack/netlabel
792  * @file: file pointer, not actually used
793  * @buf: where to get the data from
794  * @count: bytes sent
795  * @ppos: where to start
796  *
797  * Accepts only one netlbladdr per write call.
798  * Returns number of bytes written or error code, as appropriate
799  */
800 static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
801                                 size_t count, loff_t *ppos)
802 {
803         struct smk_netlbladdr *skp;
804         struct sockaddr_in newname;
805         char smack[SMK_LABELLEN];
806         char *sp;
807         char data[SMK_NETLBLADDRMAX + 1];
808         char *host = (char *)&newname.sin_addr.s_addr;
809         int rc;
810         struct netlbl_audit audit_info;
811         struct in_addr mask;
812         unsigned int m;
813         int found;
814         u32 mask_bits = (1<<31);
815         __be32 nsa;
816         u32 temp_mask;
817
818         /*
819          * Must have privilege.
820          * No partial writes.
821          * Enough data must be present.
822          * "<addr/mask, as a.b.c.d/e><space><label>"
823          * "<addr, as a.b.c.d><space><label>"
824          */
825         if (!capable(CAP_MAC_ADMIN))
826                 return -EPERM;
827         if (*ppos != 0)
828                 return -EINVAL;
829         if (count < SMK_NETLBLADDRMIN || count > SMK_NETLBLADDRMAX)
830                 return -EINVAL;
831         if (copy_from_user(data, buf, count) != 0)
832                 return -EFAULT;
833
834         data[count] = '\0';
835
836         rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd/%d %s",
837                 &host[0], &host[1], &host[2], &host[3], &m, smack);
838         if (rc != 6) {
839                 rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
840                         &host[0], &host[1], &host[2], &host[3], smack);
841                 if (rc != 5)
842                         return -EINVAL;
843                 m = BEBITS;
844         }
845         if (m > BEBITS)
846                 return -EINVAL;
847
848         /* if smack begins with '-', its an option, don't import it */
849         if (smack[0] != '-') {
850                 sp = smk_import(smack, 0);
851                 if (sp == NULL)
852                         return -EINVAL;
853         } else {
854                 /* check known options */
855                 if (strcmp(smack, smack_cipso_option) == 0)
856                         sp = (char *)smack_cipso_option;
857                 else
858                         return -EINVAL;
859         }
860
861         for (temp_mask = 0; m > 0; m--) {
862                 temp_mask |= mask_bits;
863                 mask_bits >>= 1;
864         }
865         mask.s_addr = cpu_to_be32(temp_mask);
866
867         newname.sin_addr.s_addr &= mask.s_addr;
868         /*
869          * Only allow one writer at a time. Writes should be
870          * quite rare and small in any case.
871          */
872         mutex_lock(&smk_netlbladdr_lock);
873
874         nsa = newname.sin_addr.s_addr;
875         /* try to find if the prefix is already in the list */
876         found = 0;
877         list_for_each_entry_rcu(skp, &smk_netlbladdr_list, list) {
878                 if (skp->smk_host.sin_addr.s_addr == nsa &&
879                     skp->smk_mask.s_addr == mask.s_addr) {
880                         found = 1;
881                         break;
882                 }
883         }
884         smk_netlabel_audit_set(&audit_info);
885
886         if (found == 0) {
887                 skp = kzalloc(sizeof(*skp), GFP_KERNEL);
888                 if (skp == NULL)
889                         rc = -ENOMEM;
890                 else {
891                         rc = 0;
892                         skp->smk_host.sin_addr.s_addr = newname.sin_addr.s_addr;
893                         skp->smk_mask.s_addr = mask.s_addr;
894                         skp->smk_label = sp;
895                         smk_netlbladdr_insert(skp);
896                 }
897         } else {
898                 /* we delete the unlabeled entry, only if the previous label
899                  * wasnt the special CIPSO option */
900                 if (skp->smk_label != smack_cipso_option)
901                         rc = netlbl_cfg_unlbl_static_del(&init_net, NULL,
902                                         &skp->smk_host.sin_addr, &skp->smk_mask,
903                                         PF_INET, &audit_info);
904                 else
905                         rc = 0;
906                 skp->smk_label = sp;
907         }
908
909         /*
910          * Now tell netlabel about the single label nature of
911          * this host so that incoming packets get labeled.
912          * but only if we didn't get the special CIPSO option
913          */
914         if (rc == 0 && sp != smack_cipso_option)
915                 rc = netlbl_cfg_unlbl_static_add(&init_net, NULL,
916                         &skp->smk_host.sin_addr, &skp->smk_mask, PF_INET,
917                         smack_to_secid(skp->smk_label), &audit_info);
918
919         if (rc == 0)
920                 rc = count;
921
922         mutex_unlock(&smk_netlbladdr_lock);
923
924         return rc;
925 }
926
927 static const struct file_operations smk_netlbladdr_ops = {
928         .open           = smk_open_netlbladdr,
929         .read           = seq_read,
930         .llseek         = seq_lseek,
931         .write          = smk_write_netlbladdr,
932         .release        = seq_release,
933 };
934
935 /**
936  * smk_read_doi - read() for /smack/doi
937  * @filp: file pointer, not actually used
938  * @buf: where to put the result
939  * @count: maximum to send along
940  * @ppos: where to start
941  *
942  * Returns number of bytes read or error code, as appropriate
943  */
944 static ssize_t smk_read_doi(struct file *filp, char __user *buf,
945                             size_t count, loff_t *ppos)
946 {
947         char temp[80];
948         ssize_t rc;
949
950         if (*ppos != 0)
951                 return 0;
952
953         sprintf(temp, "%d", smk_cipso_doi_value);
954         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
955
956         return rc;
957 }
958
959 /**
960  * smk_write_doi - write() for /smack/doi
961  * @file: file pointer, not actually used
962  * @buf: where to get the data from
963  * @count: bytes sent
964  * @ppos: where to start
965  *
966  * Returns number of bytes written or error code, as appropriate
967  */
968 static ssize_t smk_write_doi(struct file *file, const char __user *buf,
969                              size_t count, loff_t *ppos)
970 {
971         char temp[80];
972         int i;
973
974         if (!capable(CAP_MAC_ADMIN))
975                 return -EPERM;
976
977         if (count >= sizeof(temp) || count == 0)
978                 return -EINVAL;
979
980         if (copy_from_user(temp, buf, count) != 0)
981                 return -EFAULT;
982
983         temp[count] = '\0';
984
985         if (sscanf(temp, "%d", &i) != 1)
986                 return -EINVAL;
987
988         smk_cipso_doi_value = i;
989
990         smk_cipso_doi();
991
992         return count;
993 }
994
995 static const struct file_operations smk_doi_ops = {
996         .read           = smk_read_doi,
997         .write          = smk_write_doi,
998         .llseek         = default_llseek,
999 };
1000
1001 /**
1002  * smk_read_direct - read() for /smack/direct
1003  * @filp: file pointer, not actually used
1004  * @buf: where to put the result
1005  * @count: maximum to send along
1006  * @ppos: where to start
1007  *
1008  * Returns number of bytes read or error code, as appropriate
1009  */
1010 static ssize_t smk_read_direct(struct file *filp, char __user *buf,
1011                                size_t count, loff_t *ppos)
1012 {
1013         char temp[80];
1014         ssize_t rc;
1015
1016         if (*ppos != 0)
1017                 return 0;
1018
1019         sprintf(temp, "%d", smack_cipso_direct);
1020         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1021
1022         return rc;
1023 }
1024
1025 /**
1026  * smk_write_direct - write() for /smack/direct
1027  * @file: file pointer, not actually used
1028  * @buf: where to get the data from
1029  * @count: bytes sent
1030  * @ppos: where to start
1031  *
1032  * Returns number of bytes written or error code, as appropriate
1033  */
1034 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
1035                                 size_t count, loff_t *ppos)
1036 {
1037         char temp[80];
1038         int i;
1039
1040         if (!capable(CAP_MAC_ADMIN))
1041                 return -EPERM;
1042
1043         if (count >= sizeof(temp) || count == 0)
1044                 return -EINVAL;
1045
1046         if (copy_from_user(temp, buf, count) != 0)
1047                 return -EFAULT;
1048
1049         temp[count] = '\0';
1050
1051         if (sscanf(temp, "%d", &i) != 1)
1052                 return -EINVAL;
1053
1054         smack_cipso_direct = i;
1055
1056         return count;
1057 }
1058
1059 static const struct file_operations smk_direct_ops = {
1060         .read           = smk_read_direct,
1061         .write          = smk_write_direct,
1062         .llseek         = default_llseek,
1063 };
1064
1065 /**
1066  * smk_read_ambient - read() for /smack/ambient
1067  * @filp: file pointer, not actually used
1068  * @buf: where to put the result
1069  * @cn: maximum to send along
1070  * @ppos: where to start
1071  *
1072  * Returns number of bytes read or error code, as appropriate
1073  */
1074 static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
1075                                 size_t cn, loff_t *ppos)
1076 {
1077         ssize_t rc;
1078         int asize;
1079
1080         if (*ppos != 0)
1081                 return 0;
1082         /*
1083          * Being careful to avoid a problem in the case where
1084          * smack_net_ambient gets changed in midstream.
1085          */
1086         mutex_lock(&smack_ambient_lock);
1087
1088         asize = strlen(smack_net_ambient) + 1;
1089
1090         if (cn >= asize)
1091                 rc = simple_read_from_buffer(buf, cn, ppos,
1092                                              smack_net_ambient, asize);
1093         else
1094                 rc = -EINVAL;
1095
1096         mutex_unlock(&smack_ambient_lock);
1097
1098         return rc;
1099 }
1100
1101 /**
1102  * smk_write_ambient - write() for /smack/ambient
1103  * @file: file pointer, not actually used
1104  * @buf: where to get the data from
1105  * @count: bytes sent
1106  * @ppos: where to start
1107  *
1108  * Returns number of bytes written or error code, as appropriate
1109  */
1110 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
1111                                  size_t count, loff_t *ppos)
1112 {
1113         char in[SMK_LABELLEN];
1114         char *oldambient;
1115         char *smack;
1116
1117         if (!capable(CAP_MAC_ADMIN))
1118                 return -EPERM;
1119
1120         if (count >= SMK_LABELLEN)
1121                 return -EINVAL;
1122
1123         if (copy_from_user(in, buf, count) != 0)
1124                 return -EFAULT;
1125
1126         smack = smk_import(in, count);
1127         if (smack == NULL)
1128                 return -EINVAL;
1129
1130         mutex_lock(&smack_ambient_lock);
1131
1132         oldambient = smack_net_ambient;
1133         smack_net_ambient = smack;
1134         smk_unlbl_ambient(oldambient);
1135
1136         mutex_unlock(&smack_ambient_lock);
1137
1138         return count;
1139 }
1140
1141 static const struct file_operations smk_ambient_ops = {
1142         .read           = smk_read_ambient,
1143         .write          = smk_write_ambient,
1144         .llseek         = default_llseek,
1145 };
1146
1147 /**
1148  * smk_read_onlycap - read() for /smack/onlycap
1149  * @filp: file pointer, not actually used
1150  * @buf: where to put the result
1151  * @cn: maximum to send along
1152  * @ppos: where to start
1153  *
1154  * Returns number of bytes read or error code, as appropriate
1155  */
1156 static ssize_t smk_read_onlycap(struct file *filp, char __user *buf,
1157                                 size_t cn, loff_t *ppos)
1158 {
1159         char *smack = "";
1160         ssize_t rc = -EINVAL;
1161         int asize;
1162
1163         if (*ppos != 0)
1164                 return 0;
1165
1166         if (smack_onlycap != NULL)
1167                 smack = smack_onlycap;
1168
1169         asize = strlen(smack) + 1;
1170
1171         if (cn >= asize)
1172                 rc = simple_read_from_buffer(buf, cn, ppos, smack, asize);
1173
1174         return rc;
1175 }
1176
1177 /**
1178  * smk_write_onlycap - write() for /smack/onlycap
1179  * @file: file pointer, not actually used
1180  * @buf: where to get the data from
1181  * @count: bytes sent
1182  * @ppos: where to start
1183  *
1184  * Returns number of bytes written or error code, as appropriate
1185  */
1186 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
1187                                  size_t count, loff_t *ppos)
1188 {
1189         char in[SMK_LABELLEN];
1190         char *sp = smk_of_task(current->cred->security);
1191
1192         if (!capable(CAP_MAC_ADMIN))
1193                 return -EPERM;
1194
1195         /*
1196          * This can be done using smk_access() but is done
1197          * explicitly for clarity. The smk_access() implementation
1198          * would use smk_access(smack_onlycap, MAY_WRITE)
1199          */
1200         if (smack_onlycap != NULL && smack_onlycap != sp)
1201                 return -EPERM;
1202
1203         if (count >= SMK_LABELLEN)
1204                 return -EINVAL;
1205
1206         if (copy_from_user(in, buf, count) != 0)
1207                 return -EFAULT;
1208
1209         /*
1210          * Should the null string be passed in unset the onlycap value.
1211          * This seems like something to be careful with as usually
1212          * smk_import only expects to return NULL for errors. It
1213          * is usually the case that a nullstring or "\n" would be
1214          * bad to pass to smk_import but in fact this is useful here.
1215          */
1216         smack_onlycap = smk_import(in, count);
1217
1218         return count;
1219 }
1220
1221 static const struct file_operations smk_onlycap_ops = {
1222         .read           = smk_read_onlycap,
1223         .write          = smk_write_onlycap,
1224         .llseek         = default_llseek,
1225 };
1226
1227 /**
1228  * smk_read_logging - read() for /smack/logging
1229  * @filp: file pointer, not actually used
1230  * @buf: where to put the result
1231  * @cn: maximum to send along
1232  * @ppos: where to start
1233  *
1234  * Returns number of bytes read or error code, as appropriate
1235  */
1236 static ssize_t smk_read_logging(struct file *filp, char __user *buf,
1237                                 size_t count, loff_t *ppos)
1238 {
1239         char temp[32];
1240         ssize_t rc;
1241
1242         if (*ppos != 0)
1243                 return 0;
1244
1245         sprintf(temp, "%d\n", log_policy);
1246         rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
1247         return rc;
1248 }
1249
1250 /**
1251  * smk_write_logging - write() for /smack/logging
1252  * @file: file pointer, not actually used
1253  * @buf: where to get the data from
1254  * @count: bytes sent
1255  * @ppos: where to start
1256  *
1257  * Returns number of bytes written or error code, as appropriate
1258  */
1259 static ssize_t smk_write_logging(struct file *file, const char __user *buf,
1260                                 size_t count, loff_t *ppos)
1261 {
1262         char temp[32];
1263         int i;
1264
1265         if (!capable(CAP_MAC_ADMIN))
1266                 return -EPERM;
1267
1268         if (count >= sizeof(temp) || count == 0)
1269                 return -EINVAL;
1270
1271         if (copy_from_user(temp, buf, count) != 0)
1272                 return -EFAULT;
1273
1274         temp[count] = '\0';
1275
1276         if (sscanf(temp, "%d", &i) != 1)
1277                 return -EINVAL;
1278         if (i < 0 || i > 3)
1279                 return -EINVAL;
1280         log_policy = i;
1281         return count;
1282 }
1283
1284
1285
1286 static const struct file_operations smk_logging_ops = {
1287         .read           = smk_read_logging,
1288         .write          = smk_write_logging,
1289         .llseek         = default_llseek,
1290 };
1291 /**
1292  * smk_fill_super - fill the /smackfs superblock
1293  * @sb: the empty superblock
1294  * @data: unused
1295  * @silent: unused
1296  *
1297  * Fill in the well known entries for /smack
1298  *
1299  * Returns 0 on success, an error code on failure
1300  */
1301 static int smk_fill_super(struct super_block *sb, void *data, int silent)
1302 {
1303         int rc;
1304         struct inode *root_inode;
1305
1306         static struct tree_descr smack_files[] = {
1307                 [SMK_LOAD]      =
1308                         {"load", &smk_load_ops, S_IRUGO|S_IWUSR},
1309                 [SMK_CIPSO]     =
1310                         {"cipso", &smk_cipso_ops, S_IRUGO|S_IWUSR},
1311                 [SMK_DOI]       =
1312                         {"doi", &smk_doi_ops, S_IRUGO|S_IWUSR},
1313                 [SMK_DIRECT]    =
1314                         {"direct", &smk_direct_ops, S_IRUGO|S_IWUSR},
1315                 [SMK_AMBIENT]   =
1316                         {"ambient", &smk_ambient_ops, S_IRUGO|S_IWUSR},
1317                 [SMK_NETLBLADDR] =
1318                         {"netlabel", &smk_netlbladdr_ops, S_IRUGO|S_IWUSR},
1319                 [SMK_ONLYCAP]   =
1320                         {"onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
1321                 [SMK_LOGGING]   =
1322                         {"logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
1323                 /* last one */ {""}
1324         };
1325
1326         rc = simple_fill_super(sb, SMACK_MAGIC, smack_files);
1327         if (rc != 0) {
1328                 printk(KERN_ERR "%s failed %d while creating inodes\n",
1329                         __func__, rc);
1330                 return rc;
1331         }
1332
1333         root_inode = sb->s_root->d_inode;
1334         root_inode->i_security = new_inode_smack(smack_known_floor.smk_known);
1335
1336         return 0;
1337 }
1338
1339 /**
1340  * smk_mount - get the smackfs superblock
1341  * @fs_type: passed along without comment
1342  * @flags: passed along without comment
1343  * @dev_name: passed along without comment
1344  * @data: passed along without comment
1345  *
1346  * Just passes everything along.
1347  *
1348  * Returns what the lower level code does.
1349  */
1350 static struct dentry *smk_mount(struct file_system_type *fs_type,
1351                       int flags, const char *dev_name, void *data)
1352 {
1353         return mount_single(fs_type, flags, data, smk_fill_super);
1354 }
1355
1356 static struct file_system_type smk_fs_type = {
1357         .name           = "smackfs",
1358         .mount          = smk_mount,
1359         .kill_sb        = kill_litter_super,
1360 };
1361
1362 static struct vfsmount *smackfs_mount;
1363
1364 /**
1365  * init_smk_fs - get the smackfs superblock
1366  *
1367  * register the smackfs
1368  *
1369  * Do not register smackfs if Smack wasn't enabled
1370  * on boot. We can not put this method normally under the
1371  * smack_init() code path since the security subsystem get
1372  * initialized before the vfs caches.
1373  *
1374  * Returns true if we were not chosen on boot or if
1375  * we were chosen and filesystem registration succeeded.
1376  */
1377 static int __init init_smk_fs(void)
1378 {
1379         int err;
1380
1381         if (!security_module_enable(&smack_ops))
1382                 return 0;
1383
1384         err = register_filesystem(&smk_fs_type);
1385         if (!err) {
1386                 smackfs_mount = kern_mount(&smk_fs_type);
1387                 if (IS_ERR(smackfs_mount)) {
1388                         printk(KERN_ERR "smackfs:  could not mount!\n");
1389                         err = PTR_ERR(smackfs_mount);
1390                         smackfs_mount = NULL;
1391                 }
1392         }
1393
1394         smk_cipso_doi();
1395         smk_unlbl_ambient(NULL);
1396
1397         return err;
1398 }
1399
1400 __initcall(init_smk_fs);