1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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/slab.h>
32#include <linux/mutex.h>
33#include <linux/pipe_fs_i.h>
34#include <net/cipso_ipv4.h>
35#include <net/ip.h>
36#include <net/ipv6.h>
37#include <linux/audit.h>
38#include <linux/magic.h>
39#include <linux/dcache.h>
40#include <linux/personality.h>
41#include <linux/msg.h>
42#include <linux/shm.h>
43#include <linux/binfmts.h>
44#include "smack.h"
45
46#define task_security(task) (task_cred_xxx((task), security))
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
55LIST_HEAD(smk_ipv6_port_list);
56
57
58
59
60
61
62
63
64
65static struct smack_known *smk_fetch(const char *name, struct inode *ip,
66 struct dentry *dp)
67{
68 int rc;
69 char *buffer;
70 struct smack_known *skp = NULL;
71
72 if (ip->i_op->getxattr == NULL)
73 return NULL;
74
75 buffer = kzalloc(SMK_LONGLABEL, GFP_KERNEL);
76 if (buffer == NULL)
77 return NULL;
78
79 rc = ip->i_op->getxattr(dp, name, buffer, SMK_LONGLABEL);
80 if (rc > 0)
81 skp = smk_import_entry(buffer, rc);
82
83 kfree(buffer);
84
85 return skp;
86}
87
88
89
90
91
92
93
94struct inode_smack *new_inode_smack(char *smack)
95{
96 struct inode_smack *isp;
97
98 isp = kzalloc(sizeof(struct inode_smack), GFP_NOFS);
99 if (isp == NULL)
100 return NULL;
101
102 isp->smk_inode = smack;
103 isp->smk_flags = 0;
104 mutex_init(&isp->smk_lock);
105
106 return isp;
107}
108
109
110
111
112
113
114
115static struct task_smack *new_task_smack(struct smack_known *task,
116 struct smack_known *forked, gfp_t gfp)
117{
118 struct task_smack *tsp;
119
120 tsp = kzalloc(sizeof(struct task_smack), gfp);
121 if (tsp == NULL)
122 return NULL;
123
124 tsp->smk_task = task;
125 tsp->smk_forked = forked;
126 INIT_LIST_HEAD(&tsp->smk_rules);
127 mutex_init(&tsp->smk_rules_lock);
128
129 return tsp;
130}
131
132
133
134
135
136
137
138
139static int smk_copy_rules(struct list_head *nhead, struct list_head *ohead,
140 gfp_t gfp)
141{
142 struct smack_rule *nrp;
143 struct smack_rule *orp;
144 int rc = 0;
145
146 INIT_LIST_HEAD(nhead);
147
148 list_for_each_entry_rcu(orp, ohead, list) {
149 nrp = kzalloc(sizeof(struct smack_rule), gfp);
150 if (nrp == NULL) {
151 rc = -ENOMEM;
152 break;
153 }
154 *nrp = *orp;
155 list_add_rcu(&nrp->list, nhead);
156 }
157 return rc;
158}
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174static int smack_ptrace_access_check(struct task_struct *ctp, unsigned int mode)
175{
176 int rc;
177 struct smk_audit_info ad;
178 struct smack_known *skp;
179
180 rc = cap_ptrace_access_check(ctp, mode);
181 if (rc != 0)
182 return rc;
183
184 skp = smk_of_task(task_security(ctp));
185 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
186 smk_ad_setfield_u_tsk(&ad, ctp);
187
188 rc = smk_curacc(skp->smk_known, MAY_READWRITE, &ad);
189 return rc;
190}
191
192
193
194
195
196
197
198
199
200static int smack_ptrace_traceme(struct task_struct *ptp)
201{
202 int rc;
203 struct smk_audit_info ad;
204 struct smack_known *skp;
205
206 rc = cap_ptrace_traceme(ptp);
207 if (rc != 0)
208 return rc;
209
210 skp = smk_of_task(task_security(ptp));
211 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
212 smk_ad_setfield_u_tsk(&ad, ptp);
213
214 rc = smk_curacc(skp->smk_known, MAY_READWRITE, &ad);
215 return rc;
216}
217
218
219
220
221
222
223
224
225
226static int smack_syslog(int typefrom_file)
227{
228 int rc = 0;
229 struct smack_known *skp = smk_of_current();
230
231 if (smack_privileged(CAP_MAC_OVERRIDE))
232 return 0;
233
234 if (skp != &smack_known_floor)
235 rc = -EACCES;
236
237 return rc;
238}
239
240
241
242
243
244
245
246
247
248
249
250
251static int smack_sb_alloc_security(struct super_block *sb)
252{
253 struct superblock_smack *sbsp;
254
255 sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
256
257 if (sbsp == NULL)
258 return -ENOMEM;
259
260 sbsp->smk_root = smack_known_floor.smk_known;
261 sbsp->smk_default = smack_known_floor.smk_known;
262 sbsp->smk_floor = smack_known_floor.smk_known;
263 sbsp->smk_hat = smack_known_hat.smk_known;
264
265
266
267 sb->s_security = sbsp;
268
269 return 0;
270}
271
272
273
274
275
276
277static void smack_sb_free_security(struct super_block *sb)
278{
279 kfree(sb->s_security);
280 sb->s_security = NULL;
281}
282
283
284
285
286
287
288
289
290
291
292
293static int smack_sb_copy_data(char *orig, char *smackopts)
294{
295 char *cp, *commap, *otheropts, *dp;
296
297 otheropts = (char *)get_zeroed_page(GFP_KERNEL);
298 if (otheropts == NULL)
299 return -ENOMEM;
300
301 for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
302 if (strstr(cp, SMK_FSDEFAULT) == cp)
303 dp = smackopts;
304 else if (strstr(cp, SMK_FSFLOOR) == cp)
305 dp = smackopts;
306 else if (strstr(cp, SMK_FSHAT) == cp)
307 dp = smackopts;
308 else if (strstr(cp, SMK_FSROOT) == cp)
309 dp = smackopts;
310 else if (strstr(cp, SMK_FSTRANS) == cp)
311 dp = smackopts;
312 else
313 dp = otheropts;
314
315 commap = strchr(cp, ',');
316 if (commap != NULL)
317 *commap = '\0';
318
319 if (*dp != '\0')
320 strcat(dp, ",");
321 strcat(dp, cp);
322 }
323
324 strcpy(orig, otheropts);
325 free_page((unsigned long)otheropts);
326
327 return 0;
328}
329
330
331
332
333
334
335
336
337
338static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
339{
340 struct dentry *root = sb->s_root;
341 struct inode *inode = root->d_inode;
342 struct superblock_smack *sp = sb->s_security;
343 struct inode_smack *isp;
344 char *op;
345 char *commap;
346 char *nsp;
347 int transmute = 0;
348
349 if (sp->smk_initialized)
350 return 0;
351
352 sp->smk_initialized = 1;
353
354 for (op = data; op != NULL; op = commap) {
355 commap = strchr(op, ',');
356 if (commap != NULL)
357 *commap++ = '\0';
358
359 if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) {
360 op += strlen(SMK_FSHAT);
361 nsp = smk_import(op, 0);
362 if (nsp != NULL)
363 sp->smk_hat = nsp;
364 } else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) {
365 op += strlen(SMK_FSFLOOR);
366 nsp = smk_import(op, 0);
367 if (nsp != NULL)
368 sp->smk_floor = nsp;
369 } else if (strncmp(op, SMK_FSDEFAULT,
370 strlen(SMK_FSDEFAULT)) == 0) {
371 op += strlen(SMK_FSDEFAULT);
372 nsp = smk_import(op, 0);
373 if (nsp != NULL)
374 sp->smk_default = nsp;
375 } else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) {
376 op += strlen(SMK_FSROOT);
377 nsp = smk_import(op, 0);
378 if (nsp != NULL)
379 sp->smk_root = nsp;
380 } else if (strncmp(op, SMK_FSTRANS, strlen(SMK_FSTRANS)) == 0) {
381 op += strlen(SMK_FSTRANS);
382 nsp = smk_import(op, 0);
383 if (nsp != NULL) {
384 sp->smk_root = nsp;
385 transmute = 1;
386 }
387 }
388 }
389
390
391
392
393 isp = inode->i_security;
394 if (inode->i_security == NULL) {
395 inode->i_security = new_inode_smack(sp->smk_root);
396 isp = inode->i_security;
397 } else
398 isp->smk_inode = sp->smk_root;
399
400 if (transmute)
401 isp->smk_flags |= SMK_INODE_TRANSMUTE;
402
403 return 0;
404}
405
406
407
408
409
410
411
412
413static int smack_sb_statfs(struct dentry *dentry)
414{
415 struct superblock_smack *sbp = dentry->d_sb->s_security;
416 int rc;
417 struct smk_audit_info ad;
418
419 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
420 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
421
422 rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad);
423 return rc;
424}
425
426
427
428
429
430
431
432
433
434
435
436
437static int smack_sb_mount(const char *dev_name, struct path *path,
438 const char *type, unsigned long flags, void *data)
439{
440 struct superblock_smack *sbp = path->dentry->d_sb->s_security;
441 struct smk_audit_info ad;
442
443 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
444 smk_ad_setfield_u_fs_path(&ad, *path);
445
446 return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
447}
448
449
450
451
452
453
454
455
456
457static int smack_sb_umount(struct vfsmount *mnt, int flags)
458{
459 struct superblock_smack *sbp;
460 struct smk_audit_info ad;
461 struct path path;
462
463 path.dentry = mnt->mnt_root;
464 path.mnt = mnt;
465
466 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
467 smk_ad_setfield_u_fs_path(&ad, path);
468
469 sbp = path.dentry->d_sb->s_security;
470 return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
471}
472
473
474
475
476
477
478
479
480
481
482
483static int smack_bprm_set_creds(struct linux_binprm *bprm)
484{
485 struct inode *inode = file_inode(bprm->file);
486 struct task_smack *bsp = bprm->cred->security;
487 struct inode_smack *isp;
488 int rc;
489
490 rc = cap_bprm_set_creds(bprm);
491 if (rc != 0)
492 return rc;
493
494 if (bprm->cred_prepared)
495 return 0;
496
497 isp = inode->i_security;
498 if (isp->smk_task == NULL || isp->smk_task == bsp->smk_task)
499 return 0;
500
501 if (bprm->unsafe)
502 return -EPERM;
503
504 bsp->smk_task = isp->smk_task;
505 bprm->per_clear |= PER_CLEAR_ON_SETID;
506
507 return 0;
508}
509
510
511
512
513
514
515
516static void smack_bprm_committing_creds(struct linux_binprm *bprm)
517{
518 struct task_smack *bsp = bprm->cred->security;
519
520 if (bsp->smk_task != bsp->smk_forked)
521 current->pdeath_signal = 0;
522}
523
524
525
526
527
528
529
530static int smack_bprm_secureexec(struct linux_binprm *bprm)
531{
532 struct task_smack *tsp = current_security();
533 int ret = cap_bprm_secureexec(bprm);
534
535 if (!ret && (tsp->smk_task != tsp->smk_forked))
536 ret = 1;
537
538 return ret;
539}
540
541
542
543
544
545
546
547
548
549
550
551static int smack_inode_alloc_security(struct inode *inode)
552{
553 struct smack_known *skp = smk_of_current();
554
555 inode->i_security = new_inode_smack(skp->smk_known);
556 if (inode->i_security == NULL)
557 return -ENOMEM;
558 return 0;
559}
560
561
562
563
564
565
566
567static void smack_inode_free_security(struct inode *inode)
568{
569 kfree(inode->i_security);
570 inode->i_security = NULL;
571}
572
573
574
575
576
577
578
579
580
581
582
583
584static int smack_inode_init_security(struct inode *inode, struct inode *dir,
585 const struct qstr *qstr, char **name,
586 void **value, size_t *len)
587{
588 struct inode_smack *issp = inode->i_security;
589 struct smack_known *skp = smk_of_current();
590 char *isp = smk_of_inode(inode);
591 char *dsp = smk_of_inode(dir);
592 int may;
593
594 if (name) {
595 *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_NOFS);
596 if (*name == NULL)
597 return -ENOMEM;
598 }
599
600 if (value) {
601 rcu_read_lock();
602 may = smk_access_entry(skp->smk_known, dsp, &skp->smk_rules);
603 rcu_read_unlock();
604
605
606
607
608
609
610
611 if (may > 0 && ((may & MAY_TRANSMUTE) != 0) &&
612 smk_inode_transmutable(dir)) {
613 isp = dsp;
614 issp->smk_flags |= SMK_INODE_CHANGED;
615 }
616
617 *value = kstrdup(isp, GFP_NOFS);
618 if (*value == NULL)
619 return -ENOMEM;
620 }
621
622 if (len)
623 *len = strlen(isp) + 1;
624
625 return 0;
626}
627
628
629
630
631
632
633
634
635
636static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
637 struct dentry *new_dentry)
638{
639 char *isp;
640 struct smk_audit_info ad;
641 int rc;
642
643 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
644 smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
645
646 isp = smk_of_inode(old_dentry->d_inode);
647 rc = smk_curacc(isp, MAY_WRITE, &ad);
648
649 if (rc == 0 && new_dentry->d_inode != NULL) {
650 isp = smk_of_inode(new_dentry->d_inode);
651 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
652 rc = smk_curacc(isp, MAY_WRITE, &ad);
653 }
654
655 return rc;
656}
657
658
659
660
661
662
663
664
665
666static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
667{
668 struct inode *ip = dentry->d_inode;
669 struct smk_audit_info ad;
670 int rc;
671
672 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
673 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
674
675
676
677
678 rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad);
679 if (rc == 0) {
680
681
682
683 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
684 smk_ad_setfield_u_fs_inode(&ad, dir);
685 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
686 }
687 return rc;
688}
689
690
691
692
693
694
695
696
697
698static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
699{
700 struct smk_audit_info ad;
701 int rc;
702
703 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
704 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
705
706
707
708
709 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
710 if (rc == 0) {
711
712
713
714 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
715 smk_ad_setfield_u_fs_inode(&ad, dir);
716 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
717 }
718
719 return rc;
720}
721
722
723
724
725
726
727
728
729
730
731
732
733
734static int smack_inode_rename(struct inode *old_inode,
735 struct dentry *old_dentry,
736 struct inode *new_inode,
737 struct dentry *new_dentry)
738{
739 int rc;
740 char *isp;
741 struct smk_audit_info ad;
742
743 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
744 smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
745
746 isp = smk_of_inode(old_dentry->d_inode);
747 rc = smk_curacc(isp, MAY_READWRITE, &ad);
748
749 if (rc == 0 && new_dentry->d_inode != NULL) {
750 isp = smk_of_inode(new_dentry->d_inode);
751 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
752 rc = smk_curacc(isp, MAY_READWRITE, &ad);
753 }
754 return rc;
755}
756
757
758
759
760
761
762
763
764
765
766static int smack_inode_permission(struct inode *inode, int mask)
767{
768 struct smk_audit_info ad;
769 int no_block = mask & MAY_NOT_BLOCK;
770
771 mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
772
773
774
775 if (mask == 0)
776 return 0;
777
778
779 if (no_block)
780 return -ECHILD;
781 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
782 smk_ad_setfield_u_fs_inode(&ad, inode);
783 return smk_curacc(smk_of_inode(inode), mask, &ad);
784}
785
786
787
788
789
790
791
792
793static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
794{
795 struct smk_audit_info ad;
796
797
798
799 if (iattr->ia_valid & ATTR_FORCE)
800 return 0;
801 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
802 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
803
804 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
805}
806
807
808
809
810
811
812
813
814static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
815{
816 struct smk_audit_info ad;
817 struct path path;
818
819 path.dentry = dentry;
820 path.mnt = mnt;
821
822 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
823 smk_ad_setfield_u_fs_path(&ad, path);
824 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
825}
826
827
828
829
830
831
832
833
834
835
836
837
838
839static int smack_inode_setxattr(struct dentry *dentry, const char *name,
840 const void *value, size_t size, int flags)
841{
842 struct smk_audit_info ad;
843 int rc = 0;
844
845 if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
846 strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
847 strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
848 strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
849 strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
850 if (!smack_privileged(CAP_MAC_ADMIN))
851 rc = -EPERM;
852
853
854
855
856 if (size == 0 || size >= SMK_LONGLABEL ||
857 smk_import(value, size) == NULL)
858 rc = -EINVAL;
859 } else if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
860 if (!smack_privileged(CAP_MAC_ADMIN))
861 rc = -EPERM;
862 if (size != TRANS_TRUE_SIZE ||
863 strncmp(value, TRANS_TRUE, TRANS_TRUE_SIZE) != 0)
864 rc = -EINVAL;
865 } else
866 rc = cap_inode_setxattr(dentry, name, value, size, flags);
867
868 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
869 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
870
871 if (rc == 0)
872 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
873
874 return rc;
875}
876
877
878
879
880
881
882
883
884
885
886
887
888static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
889 const void *value, size_t size, int flags)
890{
891 struct smack_known *skp;
892 struct inode_smack *isp = dentry->d_inode->i_security;
893
894 if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) {
895 isp->smk_flags |= SMK_INODE_TRANSMUTE;
896 return;
897 }
898
899 skp = smk_import_entry(value, size);
900 if (strcmp(name, XATTR_NAME_SMACK) == 0) {
901 if (skp != NULL)
902 isp->smk_inode = skp->smk_known;
903 else
904 isp->smk_inode = smack_known_invalid.smk_known;
905 } else if (strcmp(name, XATTR_NAME_SMACKEXEC) == 0) {
906 if (skp != NULL)
907 isp->smk_task = skp;
908 else
909 isp->smk_task = &smack_known_invalid;
910 } else if (strcmp(name, XATTR_NAME_SMACKMMAP) == 0) {
911 if (skp != NULL)
912 isp->smk_mmap = skp;
913 else
914 isp->smk_mmap = &smack_known_invalid;
915 }
916
917 return;
918}
919
920
921
922
923
924
925
926
927static int smack_inode_getxattr(struct dentry *dentry, const char *name)
928{
929 struct smk_audit_info ad;
930
931 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
932 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
933
934 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
935}
936
937
938
939
940
941
942
943
944
945
946static int smack_inode_removexattr(struct dentry *dentry, const char *name)
947{
948 struct inode_smack *isp;
949 struct smk_audit_info ad;
950 int rc = 0;
951
952 if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
953 strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
954 strcmp(name, XATTR_NAME_SMACKIPOUT) == 0 ||
955 strcmp(name, XATTR_NAME_SMACKEXEC) == 0 ||
956 strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0 ||
957 strcmp(name, XATTR_NAME_SMACKMMAP)) {
958 if (!smack_privileged(CAP_MAC_ADMIN))
959 rc = -EPERM;
960 } else
961 rc = cap_inode_removexattr(dentry, name);
962
963 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY);
964 smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
965 if (rc == 0)
966 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
967
968 if (rc == 0) {
969 isp = dentry->d_inode->i_security;
970 isp->smk_task = NULL;
971 isp->smk_mmap = NULL;
972 }
973
974 return rc;
975}
976
977
978
979
980
981
982
983
984
985
986static int smack_inode_getsecurity(const struct inode *inode,
987 const char *name, void **buffer,
988 bool alloc)
989{
990 struct socket_smack *ssp;
991 struct socket *sock;
992 struct super_block *sbp;
993 struct inode *ip = (struct inode *)inode;
994 char *isp;
995 int ilen;
996 int rc = 0;
997
998 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
999 isp = smk_of_inode(inode);
1000 ilen = strlen(isp) + 1;
1001 *buffer = isp;
1002 return ilen;
1003 }
1004
1005
1006
1007
1008 sbp = ip->i_sb;
1009 if (sbp->s_magic != SOCKFS_MAGIC)
1010 return -EOPNOTSUPP;
1011
1012 sock = SOCKET_I(ip);
1013 if (sock == NULL || sock->sk == NULL)
1014 return -EOPNOTSUPP;
1015
1016 ssp = sock->sk->sk_security;
1017
1018 if (strcmp(name, XATTR_SMACK_IPIN) == 0)
1019 isp = ssp->smk_in;
1020 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
1021 isp = ssp->smk_out->smk_known;
1022 else
1023 return -EOPNOTSUPP;
1024
1025 ilen = strlen(isp) + 1;
1026 if (rc == 0) {
1027 *buffer = isp;
1028 rc = ilen;
1029 }
1030
1031 return rc;
1032}
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043static int smack_inode_listsecurity(struct inode *inode, char *buffer,
1044 size_t buffer_size)
1045{
1046 int len = strlen(XATTR_NAME_SMACK);
1047
1048 if (buffer != NULL && len <= buffer_size) {
1049 memcpy(buffer, XATTR_NAME_SMACK, len);
1050 return len;
1051 }
1052 return -EINVAL;
1053}
1054
1055
1056
1057
1058
1059
1060static void smack_inode_getsecid(const struct inode *inode, u32 *secid)
1061{
1062 struct inode_smack *isp = inode->i_security;
1063
1064 *secid = smack_to_secid(isp->smk_inode);
1065}
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085static int smack_file_permission(struct file *file, int mask)
1086{
1087 return 0;
1088}
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099static int smack_file_alloc_security(struct file *file)
1100{
1101 struct smack_known *skp = smk_of_current();
1102
1103 file->f_security = skp->smk_known;
1104 return 0;
1105}
1106
1107
1108
1109
1110
1111
1112
1113
1114static void smack_file_free_security(struct file *file)
1115{
1116 file->f_security = NULL;
1117}
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129static int smack_file_ioctl(struct file *file, unsigned int cmd,
1130 unsigned long arg)
1131{
1132 int rc = 0;
1133 struct smk_audit_info ad;
1134
1135 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1136 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1137
1138 if (_IOC_DIR(cmd) & _IOC_WRITE)
1139 rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1140
1141 if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
1142 rc = smk_curacc(file->f_security, MAY_READ, &ad);
1143
1144 return rc;
1145}
1146
1147
1148
1149
1150
1151
1152
1153
1154static int smack_file_lock(struct file *file, unsigned int cmd)
1155{
1156 struct smk_audit_info ad;
1157
1158 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1159 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1160 return smk_curacc(file->f_security, MAY_WRITE, &ad);
1161}
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175static int smack_file_fcntl(struct file *file, unsigned int cmd,
1176 unsigned long arg)
1177{
1178 struct smk_audit_info ad;
1179 int rc = 0;
1180
1181
1182 switch (cmd) {
1183 case F_GETLK:
1184 case F_SETLK:
1185 case F_SETLKW:
1186 case F_SETOWN:
1187 case F_SETSIG:
1188 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH);
1189 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1190 rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
1191 break;
1192 default:
1193 break;
1194 }
1195
1196 return rc;
1197}
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209static int smack_mmap_file(struct file *file,
1210 unsigned long reqprot, unsigned long prot,
1211 unsigned long flags)
1212{
1213 struct smack_known *skp;
1214 struct smack_known *mkp;
1215 struct smack_rule *srp;
1216 struct task_smack *tsp;
1217 char *osmack;
1218 struct inode_smack *isp;
1219 int may;
1220 int mmay;
1221 int tmay;
1222 int rc;
1223
1224 if (file == NULL)
1225 return 0;
1226
1227 isp = file_inode(file)->i_security;
1228 if (isp->smk_mmap == NULL)
1229 return 0;
1230 mkp = isp->smk_mmap;
1231
1232 tsp = current_security();
1233 skp = smk_of_current();
1234 rc = 0;
1235
1236 rcu_read_lock();
1237
1238
1239
1240
1241
1242 list_for_each_entry_rcu(srp, &skp->smk_rules, list) {
1243 osmack = srp->smk_object;
1244
1245
1246
1247 if (mkp->smk_known == osmack)
1248 continue;
1249
1250
1251
1252
1253 may = smk_access_entry(srp->smk_subject->smk_known, osmack,
1254 &tsp->smk_rules);
1255 if (may == -ENOENT)
1256 may = srp->smk_access;
1257 else
1258 may &= srp->smk_access;
1259
1260
1261
1262
1263 if (may == 0)
1264 continue;
1265
1266
1267
1268
1269
1270
1271 mmay = smk_access_entry(mkp->smk_known, osmack,
1272 &mkp->smk_rules);
1273 if (mmay == -ENOENT) {
1274 rc = -EACCES;
1275 break;
1276 }
1277
1278
1279
1280
1281 tmay = smk_access_entry(mkp->smk_known, osmack,
1282 &tsp->smk_rules);
1283 if (tmay != -ENOENT)
1284 mmay &= tmay;
1285
1286
1287
1288
1289
1290
1291 if ((may | mmay) != mmay) {
1292 rc = -EACCES;
1293 break;
1294 }
1295 }
1296
1297 rcu_read_unlock();
1298
1299 return rc;
1300}
1301
1302
1303
1304
1305
1306
1307
1308
1309static int smack_file_set_fowner(struct file *file)
1310{
1311 struct smack_known *skp = smk_of_current();
1312
1313 file->f_security = skp->smk_known;
1314 return 0;
1315}
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328static int smack_file_send_sigiotask(struct task_struct *tsk,
1329 struct fown_struct *fown, int signum)
1330{
1331 struct smack_known *skp;
1332 struct smack_known *tkp = smk_of_task(tsk->cred->security);
1333 struct file *file;
1334 int rc;
1335 struct smk_audit_info ad;
1336
1337
1338
1339
1340 file = container_of(fown, struct file, f_owner);
1341
1342
1343 skp = smk_find_entry(file->f_security);
1344 rc = smk_access(skp, tkp->smk_known, MAY_WRITE, NULL);
1345 if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE))
1346 rc = 0;
1347
1348 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1349 smk_ad_setfield_u_tsk(&ad, tsk);
1350 smack_log(file->f_security, tkp->smk_known, MAY_WRITE, rc, &ad);
1351 return rc;
1352}
1353
1354
1355
1356
1357
1358
1359
1360static int smack_file_receive(struct file *file)
1361{
1362 int may = 0;
1363 struct smk_audit_info ad;
1364
1365 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1366 smk_ad_setfield_u_fs_path(&ad, file->f_path);
1367
1368
1369
1370 if (file->f_mode & FMODE_READ)
1371 may = MAY_READ;
1372 if (file->f_mode & FMODE_WRITE)
1373 may |= MAY_WRITE;
1374
1375 return smk_curacc(file->f_security, may, &ad);
1376}
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387static int smack_file_open(struct file *file, const struct cred *cred)
1388{
1389 struct inode_smack *isp = file_inode(file)->i_security;
1390
1391 file->f_security = isp->smk_inode;
1392
1393 return 0;
1394}
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409static int smack_cred_alloc_blank(struct cred *cred, gfp_t gfp)
1410{
1411 struct task_smack *tsp;
1412
1413 tsp = new_task_smack(NULL, NULL, gfp);
1414 if (tsp == NULL)
1415 return -ENOMEM;
1416
1417 cred->security = tsp;
1418
1419 return 0;
1420}
1421
1422
1423
1424
1425
1426
1427
1428static void smack_cred_free(struct cred *cred)
1429{
1430 struct task_smack *tsp = cred->security;
1431 struct smack_rule *rp;
1432 struct list_head *l;
1433 struct list_head *n;
1434
1435 if (tsp == NULL)
1436 return;
1437 cred->security = NULL;
1438
1439 list_for_each_safe(l, n, &tsp->smk_rules) {
1440 rp = list_entry(l, struct smack_rule, list);
1441 list_del(&rp->list);
1442 kfree(rp);
1443 }
1444 kfree(tsp);
1445}
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455static int smack_cred_prepare(struct cred *new, const struct cred *old,
1456 gfp_t gfp)
1457{
1458 struct task_smack *old_tsp = old->security;
1459 struct task_smack *new_tsp;
1460 int rc;
1461
1462 new_tsp = new_task_smack(old_tsp->smk_task, old_tsp->smk_task, gfp);
1463 if (new_tsp == NULL)
1464 return -ENOMEM;
1465
1466 rc = smk_copy_rules(&new_tsp->smk_rules, &old_tsp->smk_rules, gfp);
1467 if (rc != 0)
1468 return rc;
1469
1470 new->security = new_tsp;
1471 return 0;
1472}
1473
1474
1475
1476
1477
1478
1479
1480
1481static void smack_cred_transfer(struct cred *new, const struct cred *old)
1482{
1483 struct task_smack *old_tsp = old->security;
1484 struct task_smack *new_tsp = new->security;
1485
1486 new_tsp->smk_task = old_tsp->smk_task;
1487 new_tsp->smk_forked = old_tsp->smk_task;
1488 mutex_init(&new_tsp->smk_rules_lock);
1489 INIT_LIST_HEAD(&new_tsp->smk_rules);
1490
1491
1492
1493}
1494
1495
1496
1497
1498
1499
1500
1501
1502static int smack_kernel_act_as(struct cred *new, u32 secid)
1503{
1504 struct task_smack *new_tsp = new->security;
1505 struct smack_known *skp = smack_from_secid(secid);
1506
1507 if (skp == NULL)
1508 return -EINVAL;
1509
1510 new_tsp->smk_task = skp;
1511 return 0;
1512}
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522static int smack_kernel_create_files_as(struct cred *new,
1523 struct inode *inode)
1524{
1525 struct inode_smack *isp = inode->i_security;
1526 struct task_smack *tsp = new->security;
1527
1528 tsp->smk_forked = smk_find_entry(isp->smk_inode);
1529 tsp->smk_task = tsp->smk_forked;
1530 return 0;
1531}
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541static int smk_curacc_on_task(struct task_struct *p, int access,
1542 const char *caller)
1543{
1544 struct smk_audit_info ad;
1545 struct smack_known *skp = smk_of_task(task_security(p));
1546
1547 smk_ad_init(&ad, caller, LSM_AUDIT_DATA_TASK);
1548 smk_ad_setfield_u_tsk(&ad, p);
1549 return smk_curacc(skp->smk_known, access, &ad);
1550}
1551
1552
1553
1554
1555
1556
1557
1558
1559static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
1560{
1561 return smk_curacc_on_task(p, MAY_WRITE, __func__);
1562}
1563
1564
1565
1566
1567
1568
1569
1570static int smack_task_getpgid(struct task_struct *p)
1571{
1572 return smk_curacc_on_task(p, MAY_READ, __func__);
1573}
1574
1575
1576
1577
1578
1579
1580
1581static int smack_task_getsid(struct task_struct *p)
1582{
1583 return smk_curacc_on_task(p, MAY_READ, __func__);
1584}
1585
1586
1587
1588
1589
1590
1591
1592
1593static void smack_task_getsecid(struct task_struct *p, u32 *secid)
1594{
1595 struct smack_known *skp = smk_of_task(task_security(p));
1596
1597 *secid = skp->smk_secid;
1598}
1599
1600
1601
1602
1603
1604
1605
1606
1607static int smack_task_setnice(struct task_struct *p, int nice)
1608{
1609 int rc;
1610
1611 rc = cap_task_setnice(p, nice);
1612 if (rc == 0)
1613 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1614 return rc;
1615}
1616
1617
1618
1619
1620
1621
1622
1623
1624static int smack_task_setioprio(struct task_struct *p, int ioprio)
1625{
1626 int rc;
1627
1628 rc = cap_task_setioprio(p, ioprio);
1629 if (rc == 0)
1630 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1631 return rc;
1632}
1633
1634
1635
1636
1637
1638
1639
1640static int smack_task_getioprio(struct task_struct *p)
1641{
1642 return smk_curacc_on_task(p, MAY_READ, __func__);
1643}
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653static int smack_task_setscheduler(struct task_struct *p)
1654{
1655 int rc;
1656
1657 rc = cap_task_setscheduler(p);
1658 if (rc == 0)
1659 rc = smk_curacc_on_task(p, MAY_WRITE, __func__);
1660 return rc;
1661}
1662
1663
1664
1665
1666
1667
1668
1669static int smack_task_getscheduler(struct task_struct *p)
1670{
1671 return smk_curacc_on_task(p, MAY_READ, __func__);
1672}
1673
1674
1675
1676
1677
1678
1679
1680static int smack_task_movememory(struct task_struct *p)
1681{
1682 return smk_curacc_on_task(p, MAY_WRITE, __func__);
1683}
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697static int smack_task_kill(struct task_struct *p, struct siginfo *info,
1698 int sig, u32 secid)
1699{
1700 struct smk_audit_info ad;
1701 struct smack_known *skp;
1702 struct smack_known *tkp = smk_of_task(task_security(p));
1703
1704 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
1705 smk_ad_setfield_u_tsk(&ad, p);
1706
1707
1708
1709
1710 if (secid == 0)
1711 return smk_curacc(tkp->smk_known, MAY_WRITE, &ad);
1712
1713
1714
1715
1716
1717 skp = smack_from_secid(secid);
1718 return smk_access(skp, tkp->smk_known, MAY_WRITE, &ad);
1719}
1720
1721
1722
1723
1724
1725
1726
1727static int smack_task_wait(struct task_struct *p)
1728{
1729
1730
1731
1732
1733
1734
1735
1736
1737 return 0;
1738}
1739
1740
1741
1742
1743
1744
1745
1746
1747static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
1748{
1749 struct inode_smack *isp = inode->i_security;
1750 struct smack_known *skp = smk_of_task(task_security(p));
1751
1752 isp->smk_inode = skp->smk_known;
1753}
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
1770{
1771 struct smack_known *skp = smk_of_current();
1772 struct socket_smack *ssp;
1773
1774 ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
1775 if (ssp == NULL)
1776 return -ENOMEM;
1777
1778 ssp->smk_in = skp->smk_known;
1779 ssp->smk_out = skp;
1780 ssp->smk_packet = NULL;
1781
1782 sk->sk_security = ssp;
1783
1784 return 0;
1785}
1786
1787
1788
1789
1790
1791
1792
1793static void smack_sk_free_security(struct sock *sk)
1794{
1795 kfree(sk->sk_security);
1796}
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810static char *smack_host_label(struct sockaddr_in *sip)
1811{
1812 struct smk_netlbladdr *snp;
1813 struct in_addr *siap = &sip->sin_addr;
1814
1815 if (siap->s_addr == 0)
1816 return NULL;
1817
1818 list_for_each_entry_rcu(snp, &smk_netlbladdr_list, list)
1819
1820
1821
1822
1823
1824 if ((&snp->smk_host.sin_addr)->s_addr ==
1825 (siap->s_addr & (&snp->smk_mask)->s_addr)) {
1826
1827 if (snp->smk_label == smack_cipso_option)
1828 return NULL;
1829 return snp->smk_label;
1830 }
1831
1832 return NULL;
1833}
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845static int smack_netlabel(struct sock *sk, int labeled)
1846{
1847 struct smack_known *skp;
1848 struct socket_smack *ssp = sk->sk_security;
1849 int rc = 0;
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859 local_bh_disable();
1860 bh_lock_sock_nested(sk);
1861
1862 if (ssp->smk_out == smack_net_ambient ||
1863 labeled == SMACK_UNLABELED_SOCKET)
1864 netlbl_sock_delattr(sk);
1865 else {
1866 skp = ssp->smk_out;
1867 rc = netlbl_sock_setattr(sk, sk->sk_family, &skp->smk_netlabel);
1868 }
1869
1870 bh_unlock_sock(sk);
1871 local_bh_enable();
1872
1873 return rc;
1874}
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
1888{
1889 struct smack_known *skp;
1890 int rc;
1891 int sk_lbl;
1892 char *hostsp;
1893 struct socket_smack *ssp = sk->sk_security;
1894 struct smk_audit_info ad;
1895
1896 rcu_read_lock();
1897 hostsp = smack_host_label(sap);
1898 if (hostsp != NULL) {
1899#ifdef CONFIG_AUDIT
1900 struct lsm_network_audit net;
1901
1902 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
1903 ad.a.u.net->family = sap->sin_family;
1904 ad.a.u.net->dport = sap->sin_port;
1905 ad.a.u.net->v4info.daddr = sap->sin_addr.s_addr;
1906#endif
1907 sk_lbl = SMACK_UNLABELED_SOCKET;
1908 skp = ssp->smk_out;
1909 rc = smk_access(skp, hostsp, MAY_WRITE, &ad);
1910 } else {
1911 sk_lbl = SMACK_CIPSO_SOCKET;
1912 rc = 0;
1913 }
1914 rcu_read_unlock();
1915 if (rc != 0)
1916 return rc;
1917
1918 return smack_netlabel(sk, sk_lbl);
1919}
1920
1921
1922
1923
1924
1925
1926
1927
1928static void smk_ipv6_port_label(struct socket *sock, struct sockaddr *address)
1929{
1930 struct sock *sk = sock->sk;
1931 struct sockaddr_in6 *addr6;
1932 struct socket_smack *ssp = sock->sk->sk_security;
1933 struct smk_port_label *spp;
1934 unsigned short port = 0;
1935
1936 if (address == NULL) {
1937
1938
1939
1940
1941
1942 list_for_each_entry(spp, &smk_ipv6_port_list, list) {
1943 if (sk != spp->smk_sock)
1944 continue;
1945 spp->smk_in = ssp->smk_in;
1946 spp->smk_out = ssp->smk_out;
1947 return;
1948 }
1949
1950
1951
1952
1953 return;
1954 }
1955
1956 addr6 = (struct sockaddr_in6 *)address;
1957 port = ntohs(addr6->sin6_port);
1958
1959
1960
1961 if (port == 0)
1962 return;
1963
1964
1965
1966
1967
1968 list_for_each_entry(spp, &smk_ipv6_port_list, list) {
1969 if (spp->smk_port != port)
1970 continue;
1971 spp->smk_port = port;
1972 spp->smk_sock = sk;
1973 spp->smk_in = ssp->smk_in;
1974 spp->smk_out = ssp->smk_out;
1975 return;
1976 }
1977
1978
1979
1980
1981 spp = kzalloc(sizeof(*spp), GFP_KERNEL);
1982 if (spp == NULL)
1983 return;
1984
1985 spp->smk_port = port;
1986 spp->smk_sock = sk;
1987 spp->smk_in = ssp->smk_in;
1988 spp->smk_out = ssp->smk_out;
1989
1990 list_add(&spp->list, &smk_ipv6_port_list);
1991 return;
1992}
1993
1994
1995
1996
1997
1998
1999
2000
2001static int smk_ipv6_port_check(struct sock *sk, struct sockaddr_in6 *address,
2002 int act)
2003{
2004 __be16 *bep;
2005 __be32 *be32p;
2006 struct smk_port_label *spp;
2007 struct socket_smack *ssp = sk->sk_security;
2008 struct smack_known *skp;
2009 unsigned short port = 0;
2010 char *object;
2011 struct smk_audit_info ad;
2012#ifdef CONFIG_AUDIT
2013 struct lsm_network_audit net;
2014#endif
2015
2016 if (act == SMK_RECEIVING) {
2017 skp = smack_net_ambient;
2018 object = ssp->smk_in;
2019 } else {
2020 skp = ssp->smk_out;
2021 object = smack_net_ambient->smk_known;
2022 }
2023
2024
2025
2026
2027 port = ntohs(address->sin6_port);
2028 bep = (__be16 *)(&address->sin6_addr);
2029 be32p = (__be32 *)(&address->sin6_addr);
2030
2031
2032
2033
2034 if (be32p[0] || be32p[1] || be32p[2] || bep[6] || ntohs(bep[7]) != 1)
2035 goto auditout;
2036
2037
2038
2039
2040 if (act == SMK_RECEIVING) {
2041 skp = &smack_known_web;
2042 goto auditout;
2043 }
2044
2045 list_for_each_entry(spp, &smk_ipv6_port_list, list) {
2046 if (spp->smk_port != port)
2047 continue;
2048 object = spp->smk_in;
2049 if (act == SMK_CONNECTING)
2050 ssp->smk_packet = spp->smk_out->smk_known;
2051 break;
2052 }
2053
2054auditout:
2055
2056#ifdef CONFIG_AUDIT
2057 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2058 ad.a.u.net->family = sk->sk_family;
2059 ad.a.u.net->dport = port;
2060 if (act == SMK_RECEIVING)
2061 ad.a.u.net->v6info.saddr = address->sin6_addr;
2062 else
2063 ad.a.u.net->v6info.daddr = address->sin6_addr;
2064#endif
2065 return smk_access(skp, object, MAY_WRITE, &ad);
2066}
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080static int smack_inode_setsecurity(struct inode *inode, const char *name,
2081 const void *value, size_t size, int flags)
2082{
2083 struct smack_known *skp;
2084 struct inode_smack *nsp = inode->i_security;
2085 struct socket_smack *ssp;
2086 struct socket *sock;
2087 int rc = 0;
2088
2089 if (value == NULL || size > SMK_LONGLABEL || size == 0)
2090 return -EACCES;
2091
2092 skp = smk_import_entry(value, size);
2093 if (skp == NULL)
2094 return -EINVAL;
2095
2096 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
2097 nsp->smk_inode = skp->smk_known;
2098 nsp->smk_flags |= SMK_INODE_INSTANT;
2099 return 0;
2100 }
2101
2102
2103
2104 if (inode->i_sb->s_magic != SOCKFS_MAGIC)
2105 return -EOPNOTSUPP;
2106
2107 sock = SOCKET_I(inode);
2108 if (sock == NULL || sock->sk == NULL)
2109 return -EOPNOTSUPP;
2110
2111 ssp = sock->sk->sk_security;
2112
2113 if (strcmp(name, XATTR_SMACK_IPIN) == 0)
2114 ssp->smk_in = skp->smk_known;
2115 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
2116 ssp->smk_out = skp;
2117 if (sock->sk->sk_family == PF_INET) {
2118 rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2119 if (rc != 0)
2120 printk(KERN_WARNING
2121 "Smack: \"%s\" netlbl error %d.\n",
2122 __func__, -rc);
2123 }
2124 } else
2125 return -EOPNOTSUPP;
2126
2127 if (sock->sk->sk_family == PF_INET6)
2128 smk_ipv6_port_label(sock, NULL);
2129
2130 return 0;
2131}
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145static int smack_socket_post_create(struct socket *sock, int family,
2146 int type, int protocol, int kern)
2147{
2148 if (family != PF_INET || sock->sk == NULL)
2149 return 0;
2150
2151
2152
2153 return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2154}
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166static int smack_socket_bind(struct socket *sock, struct sockaddr *address,
2167 int addrlen)
2168{
2169 if (sock->sk != NULL && sock->sk->sk_family == PF_INET6)
2170 smk_ipv6_port_label(sock, address);
2171
2172 return 0;
2173}
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
2186 int addrlen)
2187{
2188 int rc = 0;
2189
2190 if (sock->sk == NULL)
2191 return 0;
2192
2193 switch (sock->sk->sk_family) {
2194 case PF_INET:
2195 if (addrlen < sizeof(struct sockaddr_in))
2196 return -EINVAL;
2197 rc = smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap);
2198 break;
2199 case PF_INET6:
2200 if (addrlen < sizeof(struct sockaddr_in6))
2201 return -EINVAL;
2202 rc = smk_ipv6_port_check(sock->sk, (struct sockaddr_in6 *)sap,
2203 SMK_CONNECTING);
2204 break;
2205 }
2206 return rc;
2207}
2208
2209
2210
2211
2212
2213
2214
2215static int smack_flags_to_may(int flags)
2216{
2217 int may = 0;
2218
2219 if (flags & S_IRUGO)
2220 may |= MAY_READ;
2221 if (flags & S_IWUGO)
2222 may |= MAY_WRITE;
2223 if (flags & S_IXUGO)
2224 may |= MAY_EXEC;
2225
2226 return may;
2227}
2228
2229
2230
2231
2232
2233
2234
2235static int smack_msg_msg_alloc_security(struct msg_msg *msg)
2236{
2237 struct smack_known *skp = smk_of_current();
2238
2239 msg->security = skp->smk_known;
2240 return 0;
2241}
2242
2243
2244
2245
2246
2247
2248
2249static void smack_msg_msg_free_security(struct msg_msg *msg)
2250{
2251 msg->security = NULL;
2252}
2253
2254
2255
2256
2257
2258
2259
2260static char *smack_of_shm(struct shmid_kernel *shp)
2261{
2262 return (char *)shp->shm_perm.security;
2263}
2264
2265
2266
2267
2268
2269
2270
2271static int smack_shm_alloc_security(struct shmid_kernel *shp)
2272{
2273 struct kern_ipc_perm *isp = &shp->shm_perm;
2274 struct smack_known *skp = smk_of_current();
2275
2276 isp->security = skp->smk_known;
2277 return 0;
2278}
2279
2280
2281
2282
2283
2284
2285
2286static void smack_shm_free_security(struct shmid_kernel *shp)
2287{
2288 struct kern_ipc_perm *isp = &shp->shm_perm;
2289
2290 isp->security = NULL;
2291}
2292
2293
2294
2295
2296
2297
2298
2299
2300static int smk_curacc_shm(struct shmid_kernel *shp, int access)
2301{
2302 char *ssp = smack_of_shm(shp);
2303 struct smk_audit_info ad;
2304
2305#ifdef CONFIG_AUDIT
2306 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2307 ad.a.u.ipc_id = shp->shm_perm.id;
2308#endif
2309 return smk_curacc(ssp, access, &ad);
2310}
2311
2312
2313
2314
2315
2316
2317
2318
2319static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
2320{
2321 int may;
2322
2323 may = smack_flags_to_may(shmflg);
2324 return smk_curacc_shm(shp, may);
2325}
2326
2327
2328
2329
2330
2331
2332
2333
2334static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
2335{
2336 int may;
2337
2338 switch (cmd) {
2339 case IPC_STAT:
2340 case SHM_STAT:
2341 may = MAY_READ;
2342 break;
2343 case IPC_SET:
2344 case SHM_LOCK:
2345 case SHM_UNLOCK:
2346 case IPC_RMID:
2347 may = MAY_READWRITE;
2348 break;
2349 case IPC_INFO:
2350 case SHM_INFO:
2351
2352
2353
2354 return 0;
2355 default:
2356 return -EINVAL;
2357 }
2358 return smk_curacc_shm(shp, may);
2359}
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
2370 int shmflg)
2371{
2372 int may;
2373
2374 may = smack_flags_to_may(shmflg);
2375 return smk_curacc_shm(shp, may);
2376}
2377
2378
2379
2380
2381
2382
2383
2384static char *smack_of_sem(struct sem_array *sma)
2385{
2386 return (char *)sma->sem_perm.security;
2387}
2388
2389
2390
2391
2392
2393
2394
2395static int smack_sem_alloc_security(struct sem_array *sma)
2396{
2397 struct kern_ipc_perm *isp = &sma->sem_perm;
2398 struct smack_known *skp = smk_of_current();
2399
2400 isp->security = skp->smk_known;
2401 return 0;
2402}
2403
2404
2405
2406
2407
2408
2409
2410static void smack_sem_free_security(struct sem_array *sma)
2411{
2412 struct kern_ipc_perm *isp = &sma->sem_perm;
2413
2414 isp->security = NULL;
2415}
2416
2417
2418
2419
2420
2421
2422
2423
2424static int smk_curacc_sem(struct sem_array *sma, int access)
2425{
2426 char *ssp = smack_of_sem(sma);
2427 struct smk_audit_info ad;
2428
2429#ifdef CONFIG_AUDIT
2430 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2431 ad.a.u.ipc_id = sma->sem_perm.id;
2432#endif
2433 return smk_curacc(ssp, access, &ad);
2434}
2435
2436
2437
2438
2439
2440
2441
2442
2443static int smack_sem_associate(struct sem_array *sma, int semflg)
2444{
2445 int may;
2446
2447 may = smack_flags_to_may(semflg);
2448 return smk_curacc_sem(sma, may);
2449}
2450
2451
2452
2453
2454
2455
2456
2457
2458static int smack_sem_semctl(struct sem_array *sma, int cmd)
2459{
2460 int may;
2461
2462 switch (cmd) {
2463 case GETPID:
2464 case GETNCNT:
2465 case GETZCNT:
2466 case GETVAL:
2467 case GETALL:
2468 case IPC_STAT:
2469 case SEM_STAT:
2470 may = MAY_READ;
2471 break;
2472 case SETVAL:
2473 case SETALL:
2474 case IPC_RMID:
2475 case IPC_SET:
2476 may = MAY_READWRITE;
2477 break;
2478 case IPC_INFO:
2479 case SEM_INFO:
2480
2481
2482
2483 return 0;
2484 default:
2485 return -EINVAL;
2486 }
2487
2488 return smk_curacc_sem(sma, may);
2489}
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
2503 unsigned nsops, int alter)
2504{
2505 return smk_curacc_sem(sma, MAY_READWRITE);
2506}
2507
2508
2509
2510
2511
2512
2513
2514static int smack_msg_queue_alloc_security(struct msg_queue *msq)
2515{
2516 struct kern_ipc_perm *kisp = &msq->q_perm;
2517 struct smack_known *skp = smk_of_current();
2518
2519 kisp->security = skp->smk_known;
2520 return 0;
2521}
2522
2523
2524
2525
2526
2527
2528
2529static void smack_msg_queue_free_security(struct msg_queue *msq)
2530{
2531 struct kern_ipc_perm *kisp = &msq->q_perm;
2532
2533 kisp->security = NULL;
2534}
2535
2536
2537
2538
2539
2540
2541
2542static char *smack_of_msq(struct msg_queue *msq)
2543{
2544 return (char *)msq->q_perm.security;
2545}
2546
2547
2548
2549
2550
2551
2552
2553
2554static int smk_curacc_msq(struct msg_queue *msq, int access)
2555{
2556 char *msp = smack_of_msq(msq);
2557 struct smk_audit_info ad;
2558
2559#ifdef CONFIG_AUDIT
2560 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2561 ad.a.u.ipc_id = msq->q_perm.id;
2562#endif
2563 return smk_curacc(msp, access, &ad);
2564}
2565
2566
2567
2568
2569
2570
2571
2572
2573static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
2574{
2575 int may;
2576
2577 may = smack_flags_to_may(msqflg);
2578 return smk_curacc_msq(msq, may);
2579}
2580
2581
2582
2583
2584
2585
2586
2587
2588static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
2589{
2590 int may;
2591
2592 switch (cmd) {
2593 case IPC_STAT:
2594 case MSG_STAT:
2595 may = MAY_READ;
2596 break;
2597 case IPC_SET:
2598 case IPC_RMID:
2599 may = MAY_READWRITE;
2600 break;
2601 case IPC_INFO:
2602 case MSG_INFO:
2603
2604
2605
2606 return 0;
2607 default:
2608 return -EINVAL;
2609 }
2610
2611 return smk_curacc_msq(msq, may);
2612}
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
2623 int msqflg)
2624{
2625 int may;
2626
2627 may = smack_flags_to_may(msqflg);
2628 return smk_curacc_msq(msq, may);
2629}
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
2642 struct task_struct *target, long type, int mode)
2643{
2644 return smk_curacc_msq(msq, MAY_READWRITE);
2645}
2646
2647
2648
2649
2650
2651
2652
2653
2654static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
2655{
2656 char *isp = ipp->security;
2657 int may = smack_flags_to_may(flag);
2658 struct smk_audit_info ad;
2659
2660#ifdef CONFIG_AUDIT
2661 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
2662 ad.a.u.ipc_id = ipp->id;
2663#endif
2664 return smk_curacc(isp, may, &ad);
2665}
2666
2667
2668
2669
2670
2671
2672static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
2673{
2674 char *smack = ipp->security;
2675
2676 *secid = smack_to_secid(smack);
2677}
2678
2679
2680
2681
2682
2683
2684
2685
2686static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
2687{
2688 struct super_block *sbp;
2689 struct superblock_smack *sbsp;
2690 struct inode_smack *isp;
2691 struct smack_known *skp;
2692 struct smack_known *ckp = smk_of_current();
2693 char *final;
2694 char trattr[TRANS_TRUE_SIZE];
2695 int transflag = 0;
2696 int rc;
2697 struct dentry *dp;
2698
2699 if (inode == NULL)
2700 return;
2701
2702 isp = inode->i_security;
2703
2704 mutex_lock(&isp->smk_lock);
2705
2706
2707
2708
2709 if (isp->smk_flags & SMK_INODE_INSTANT)
2710 goto unlockandout;
2711
2712 sbp = inode->i_sb;
2713 sbsp = sbp->s_security;
2714
2715
2716
2717
2718 final = sbsp->smk_default;
2719
2720
2721
2722
2723
2724
2725
2726 if (opt_dentry->d_parent == opt_dentry) {
2727 isp->smk_inode = sbsp->smk_root;
2728 isp->smk_flags |= SMK_INODE_INSTANT;
2729 goto unlockandout;
2730 }
2731
2732
2733
2734
2735
2736
2737
2738 switch (sbp->s_magic) {
2739 case SMACK_MAGIC:
2740
2741
2742
2743
2744
2745 final = smack_known_star.smk_known;
2746 break;
2747 case PIPEFS_MAGIC:
2748
2749
2750
2751 final = smack_known_star.smk_known;
2752 break;
2753 case DEVPTS_SUPER_MAGIC:
2754
2755
2756
2757
2758
2759 final = ckp->smk_known;
2760 break;
2761 case SOCKFS_MAGIC:
2762
2763
2764
2765
2766 final = smack_known_star.smk_known;
2767 break;
2768 case PROC_SUPER_MAGIC:
2769
2770
2771
2772
2773 break;
2774 case TMPFS_MAGIC:
2775
2776
2777
2778
2779
2780 final = smack_known_star.smk_known;
2781
2782
2783
2784
2785
2786
2787
2788
2789 default:
2790
2791
2792
2793
2794
2795
2796
2797
2798 if (S_ISSOCK(inode->i_mode)) {
2799 final = smack_known_star.smk_known;
2800 break;
2801 }
2802
2803
2804
2805
2806
2807
2808 if (inode->i_op->getxattr == NULL)
2809 break;
2810
2811
2812
2813 dp = dget(opt_dentry);
2814 skp = smk_fetch(XATTR_NAME_SMACK, inode, dp);
2815 if (skp != NULL)
2816 final = skp->smk_known;
2817
2818
2819
2820
2821 if (S_ISDIR(inode->i_mode)) {
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831 if (isp->smk_flags & SMK_INODE_CHANGED) {
2832 isp->smk_flags &= ~SMK_INODE_CHANGED;
2833 rc = inode->i_op->setxattr(dp,
2834 XATTR_NAME_SMACKTRANSMUTE,
2835 TRANS_TRUE, TRANS_TRUE_SIZE,
2836 0);
2837 } else {
2838 rc = inode->i_op->getxattr(dp,
2839 XATTR_NAME_SMACKTRANSMUTE, trattr,
2840 TRANS_TRUE_SIZE);
2841 if (rc >= 0 && strncmp(trattr, TRANS_TRUE,
2842 TRANS_TRUE_SIZE) != 0)
2843 rc = -EINVAL;
2844 }
2845 if (rc >= 0)
2846 transflag = SMK_INODE_TRANSMUTE;
2847 }
2848 isp->smk_task = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp);
2849 isp->smk_mmap = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp);
2850
2851 dput(dp);
2852 break;
2853 }
2854
2855 if (final == NULL)
2856 isp->smk_inode = ckp->smk_known;
2857 else
2858 isp->smk_inode = final;
2859
2860 isp->smk_flags |= (SMK_INODE_INSTANT | transflag);
2861
2862unlockandout:
2863 mutex_unlock(&isp->smk_lock);
2864 return;
2865}
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877static int smack_getprocattr(struct task_struct *p, char *name, char **value)
2878{
2879 struct smack_known *skp = smk_of_task(task_security(p));
2880 char *cp;
2881 int slen;
2882
2883 if (strcmp(name, "current") != 0)
2884 return -EINVAL;
2885
2886 cp = kstrdup(skp->smk_known, GFP_KERNEL);
2887 if (cp == NULL)
2888 return -ENOMEM;
2889
2890 slen = strlen(cp);
2891 *value = cp;
2892 return slen;
2893}
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907static int smack_setprocattr(struct task_struct *p, char *name,
2908 void *value, size_t size)
2909{
2910 struct task_smack *tsp;
2911 struct cred *new;
2912 struct smack_known *skp;
2913
2914
2915
2916
2917
2918 if (p != current)
2919 return -EPERM;
2920
2921 if (!smack_privileged(CAP_MAC_ADMIN))
2922 return -EPERM;
2923
2924 if (value == NULL || size == 0 || size >= SMK_LONGLABEL)
2925 return -EINVAL;
2926
2927 if (strcmp(name, "current") != 0)
2928 return -EINVAL;
2929
2930 skp = smk_import_entry(value, size);
2931 if (skp == NULL)
2932 return -EINVAL;
2933
2934
2935
2936
2937 if (skp == &smack_known_web)
2938 return -EPERM;
2939
2940 new = prepare_creds();
2941 if (new == NULL)
2942 return -ENOMEM;
2943
2944 tsp = new->security;
2945 tsp->smk_task = skp;
2946
2947 commit_creds(new);
2948 return size;
2949}
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960static int smack_unix_stream_connect(struct sock *sock,
2961 struct sock *other, struct sock *newsk)
2962{
2963 struct smack_known *skp;
2964 struct socket_smack *ssp = sock->sk_security;
2965 struct socket_smack *osp = other->sk_security;
2966 struct socket_smack *nsp = newsk->sk_security;
2967 struct smk_audit_info ad;
2968 int rc = 0;
2969
2970#ifdef CONFIG_AUDIT
2971 struct lsm_network_audit net;
2972
2973 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2974 smk_ad_setfield_u_net_sk(&ad, other);
2975#endif
2976
2977 if (!smack_privileged(CAP_MAC_OVERRIDE)) {
2978 skp = ssp->smk_out;
2979 rc = smk_access(skp, osp->smk_in, MAY_WRITE, &ad);
2980 }
2981
2982
2983
2984
2985 if (rc == 0) {
2986 nsp->smk_packet = ssp->smk_out->smk_known;
2987 ssp->smk_packet = osp->smk_out->smk_known;
2988 }
2989
2990 return rc;
2991}
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001static int smack_unix_may_send(struct socket *sock, struct socket *other)
3002{
3003 struct socket_smack *ssp = sock->sk->sk_security;
3004 struct socket_smack *osp = other->sk->sk_security;
3005 struct smack_known *skp;
3006 struct smk_audit_info ad;
3007
3008#ifdef CONFIG_AUDIT
3009 struct lsm_network_audit net;
3010
3011 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3012 smk_ad_setfield_u_net_sk(&ad, other->sk);
3013#endif
3014
3015 if (smack_privileged(CAP_MAC_OVERRIDE))
3016 return 0;
3017
3018 skp = ssp->smk_out;
3019 return smk_access(skp, osp->smk_in, MAY_WRITE, &ad);
3020}
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
3033 int size)
3034{
3035 struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;
3036 struct sockaddr_in6 *sap = (struct sockaddr_in6 *) msg->msg_name;
3037 int rc = 0;
3038
3039
3040
3041
3042 if (sip == NULL)
3043 return 0;
3044
3045 switch (sip->sin_family) {
3046 case AF_INET:
3047 rc = smack_netlabel_send(sock->sk, sip);
3048 break;
3049 case AF_INET6:
3050 rc = smk_ipv6_port_check(sock->sk, sap, SMK_SENDING);
3051 break;
3052 }
3053 return rc;
3054}
3055
3056
3057
3058
3059
3060
3061
3062
3063static struct smack_known *smack_from_secattr(struct netlbl_lsm_secattr *sap,
3064 struct socket_smack *ssp)
3065{
3066 struct smack_known *skp;
3067 int found = 0;
3068
3069 if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080 rcu_read_lock();
3081 list_for_each_entry(skp, &smack_known_list, list) {
3082 if (sap->attr.mls.lvl != skp->smk_netlabel.attr.mls.lvl)
3083 continue;
3084 if (memcmp(sap->attr.mls.cat,
3085 skp->smk_netlabel.attr.mls.cat,
3086 SMK_CIPSOLEN) != 0)
3087 continue;
3088 found = 1;
3089 break;
3090 }
3091 rcu_read_unlock();
3092
3093 if (found)
3094 return skp;
3095
3096 if (ssp != NULL && ssp->smk_in == smack_known_star.smk_known)
3097 return &smack_known_web;
3098 return &smack_known_star;
3099 }
3100 if ((sap->flags & NETLBL_SECATTR_SECID) != 0) {
3101
3102
3103
3104 skp = smack_from_secid(sap->attr.secid);
3105
3106
3107
3108
3109
3110
3111
3112 BUG_ON(skp == NULL);
3113 return skp;
3114 }
3115
3116
3117
3118
3119
3120 return smack_net_ambient;
3121}
3122
3123static int smk_skb_to_addr_ipv6(struct sk_buff *skb, struct sockaddr_in6 *sip)
3124{
3125 u8 nexthdr;
3126 int offset;
3127 int proto = -EINVAL;
3128 struct ipv6hdr _ipv6h;
3129 struct ipv6hdr *ip6;
3130 __be16 frag_off;
3131 struct tcphdr _tcph, *th;
3132 struct udphdr _udph, *uh;
3133 struct dccp_hdr _dccph, *dh;
3134
3135 sip->sin6_port = 0;
3136
3137 offset = skb_network_offset(skb);
3138 ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3139 if (ip6 == NULL)
3140 return -EINVAL;
3141 sip->sin6_addr = ip6->saddr;
3142
3143 nexthdr = ip6->nexthdr;
3144 offset += sizeof(_ipv6h);
3145 offset = ipv6_skip_exthdr(skb, offset, &nexthdr, &frag_off);
3146 if (offset < 0)
3147 return -EINVAL;
3148
3149 proto = nexthdr;
3150 switch (proto) {
3151 case IPPROTO_TCP:
3152 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3153 if (th != NULL)
3154 sip->sin6_port = th->source;
3155 break;
3156 case IPPROTO_UDP:
3157 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3158 if (uh != NULL)
3159 sip->sin6_port = uh->source;
3160 break;
3161 case IPPROTO_DCCP:
3162 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3163 if (dh != NULL)
3164 sip->sin6_port = dh->dccph_sport;
3165 break;
3166 }
3167 return proto;
3168}
3169
3170
3171
3172
3173
3174
3175
3176
3177static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
3178{
3179 struct netlbl_lsm_secattr secattr;
3180 struct socket_smack *ssp = sk->sk_security;
3181 struct smack_known *skp;
3182 struct sockaddr_in6 sadd;
3183 int rc = 0;
3184 struct smk_audit_info ad;
3185#ifdef CONFIG_AUDIT
3186 struct lsm_network_audit net;
3187#endif
3188 switch (sk->sk_family) {
3189 case PF_INET:
3190
3191
3192
3193 netlbl_secattr_init(&secattr);
3194
3195 rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
3196 if (rc == 0)
3197 skp = smack_from_secattr(&secattr, ssp);
3198 else
3199 skp = smack_net_ambient;
3200
3201 netlbl_secattr_destroy(&secattr);
3202
3203#ifdef CONFIG_AUDIT
3204 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3205 ad.a.u.net->family = sk->sk_family;
3206 ad.a.u.net->netif = skb->skb_iif;
3207 ipv4_skb_to_auditdata(skb, &ad.a, NULL);
3208#endif
3209
3210
3211
3212
3213
3214
3215 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
3216 if (rc != 0)
3217 netlbl_skbuff_err(skb, rc, 0);
3218 break;
3219 case PF_INET6:
3220 rc = smk_skb_to_addr_ipv6(skb, &sadd);
3221 if (rc == IPPROTO_UDP || rc == IPPROTO_TCP)
3222 rc = smk_ipv6_port_check(sk, &sadd, SMK_RECEIVING);
3223 else
3224 rc = 0;
3225 break;
3226 }
3227 return rc;
3228}
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239static int smack_socket_getpeersec_stream(struct socket *sock,
3240 char __user *optval,
3241 int __user *optlen, unsigned len)
3242{
3243 struct socket_smack *ssp;
3244 char *rcp = "";
3245 int slen = 1;
3246 int rc = 0;
3247
3248 ssp = sock->sk->sk_security;
3249 if (ssp->smk_packet != NULL) {
3250 rcp = ssp->smk_packet;
3251 slen = strlen(rcp) + 1;
3252 }
3253
3254 if (slen > len)
3255 rc = -ERANGE;
3256 else if (copy_to_user(optval, rcp, slen) != 0)
3257 rc = -EFAULT;
3258
3259 if (put_user(slen, optlen) != 0)
3260 rc = -EFAULT;
3261
3262 return rc;
3263}
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274static int smack_socket_getpeersec_dgram(struct socket *sock,
3275 struct sk_buff *skb, u32 *secid)
3276
3277{
3278 struct netlbl_lsm_secattr secattr;
3279 struct socket_smack *ssp = NULL;
3280 struct smack_known *skp;
3281 int family = PF_UNSPEC;
3282 u32 s = 0;
3283 int rc;
3284
3285 if (skb != NULL) {
3286 if (skb->protocol == htons(ETH_P_IP))
3287 family = PF_INET;
3288 else if (skb->protocol == htons(ETH_P_IPV6))
3289 family = PF_INET6;
3290 }
3291 if (family == PF_UNSPEC && sock != NULL)
3292 family = sock->sk->sk_family;
3293
3294 if (family == PF_UNIX) {
3295 ssp = sock->sk->sk_security;
3296 s = ssp->smk_out->smk_secid;
3297 } else if (family == PF_INET || family == PF_INET6) {
3298
3299
3300
3301 if (sock != NULL && sock->sk != NULL)
3302 ssp = sock->sk->sk_security;
3303 netlbl_secattr_init(&secattr);
3304 rc = netlbl_skbuff_getattr(skb, family, &secattr);
3305 if (rc == 0) {
3306 skp = smack_from_secattr(&secattr, ssp);
3307 s = skp->smk_secid;
3308 }
3309 netlbl_secattr_destroy(&secattr);
3310 }
3311 *secid = s;
3312 if (s == 0)
3313 return -EINVAL;
3314 return 0;
3315}
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325static void smack_sock_graft(struct sock *sk, struct socket *parent)
3326{
3327 struct socket_smack *ssp;
3328 struct smack_known *skp = smk_of_current();
3329
3330 if (sk == NULL ||
3331 (sk->sk_family != PF_INET && sk->sk_family != PF_INET6))
3332 return;
3333
3334 ssp = sk->sk_security;
3335 ssp->smk_in = skp->smk_known;
3336 ssp->smk_out = skp;
3337
3338}
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
3350 struct request_sock *req)
3351{
3352 u16 family = sk->sk_family;
3353 struct smack_known *skp;
3354 struct socket_smack *ssp = sk->sk_security;
3355 struct netlbl_lsm_secattr secattr;
3356 struct sockaddr_in addr;
3357 struct iphdr *hdr;
3358 char *hsp;
3359 int rc;
3360 struct smk_audit_info ad;
3361#ifdef CONFIG_AUDIT
3362 struct lsm_network_audit net;
3363#endif
3364
3365 if (family == PF_INET6) {
3366
3367
3368
3369
3370
3371 if (skb->protocol == htons(ETH_P_IP))
3372 family = PF_INET;
3373 else
3374 return 0;
3375 }
3376
3377 netlbl_secattr_init(&secattr);
3378 rc = netlbl_skbuff_getattr(skb, family, &secattr);
3379 if (rc == 0)
3380 skp = smack_from_secattr(&secattr, ssp);
3381 else
3382 skp = &smack_known_huh;
3383 netlbl_secattr_destroy(&secattr);
3384
3385#ifdef CONFIG_AUDIT
3386 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3387 ad.a.u.net->family = family;
3388 ad.a.u.net->netif = skb->skb_iif;
3389 ipv4_skb_to_auditdata(skb, &ad.a, NULL);
3390#endif
3391
3392
3393
3394
3395 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
3396 if (rc != 0)
3397 return rc;
3398
3399
3400
3401
3402
3403 req->peer_secid = skp->smk_secid;
3404
3405
3406
3407
3408
3409
3410 hdr = ip_hdr(skb);
3411 addr.sin_addr.s_addr = hdr->saddr;
3412 rcu_read_lock();
3413 hsp = smack_host_label(&addr);
3414 rcu_read_unlock();
3415
3416 if (hsp == NULL)
3417 rc = netlbl_req_setattr(req, &skp->smk_netlabel);
3418 else
3419 netlbl_req_delattr(req);
3420
3421 return rc;
3422}
3423
3424
3425
3426
3427
3428
3429
3430
3431static void smack_inet_csk_clone(struct sock *sk,
3432 const struct request_sock *req)
3433{
3434 struct socket_smack *ssp = sk->sk_security;
3435 struct smack_known *skp;
3436
3437 if (req->peer_secid != 0) {
3438 skp = smack_from_secid(req->peer_secid);
3439 ssp->smk_packet = skp->smk_known;
3440 } else
3441 ssp->smk_packet = NULL;
3442}
3443
3444
3445
3446
3447
3448
3449
3450
3451#ifdef CONFIG_KEYS
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463static int smack_key_alloc(struct key *key, const struct cred *cred,
3464 unsigned long flags)
3465{
3466 struct smack_known *skp = smk_of_task(cred->security);
3467
3468 key->security = skp->smk_known;
3469 return 0;
3470}
3471
3472
3473
3474
3475
3476
3477
3478static void smack_key_free(struct key *key)
3479{
3480 key->security = NULL;
3481}
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492static int smack_key_permission(key_ref_t key_ref,
3493 const struct cred *cred, key_perm_t perm)
3494{
3495 struct key *keyp;
3496 struct smk_audit_info ad;
3497 struct smack_known *tkp = smk_of_task(cred->security);
3498
3499 keyp = key_ref_to_ptr(key_ref);
3500 if (keyp == NULL)
3501 return -EINVAL;
3502
3503
3504
3505
3506 if (keyp->security == NULL)
3507 return 0;
3508
3509
3510
3511 if (tkp == NULL)
3512 return -EACCES;
3513#ifdef CONFIG_AUDIT
3514 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY);
3515 ad.a.u.key_struct.key = keyp->serial;
3516 ad.a.u.key_struct.key_desc = keyp->description;
3517#endif
3518 return smk_access(tkp, keyp->security, MAY_READWRITE, &ad);
3519}
3520#endif
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535#ifdef CONFIG_AUDIT
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
3548{
3549 char **rule = (char **)vrule;
3550 *rule = NULL;
3551
3552 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
3553 return -EINVAL;
3554
3555 if (op != Audit_equal && op != Audit_not_equal)
3556 return -EINVAL;
3557
3558 *rule = smk_import(rulestr, 0);
3559
3560 return 0;
3561}
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571static int smack_audit_rule_known(struct audit_krule *krule)
3572{
3573 struct audit_field *f;
3574 int i;
3575
3576 for (i = 0; i < krule->field_count; i++) {
3577 f = &krule->fields[i];
3578
3579 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
3580 return 1;
3581 }
3582
3583 return 0;
3584}
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
3598 struct audit_context *actx)
3599{
3600 struct smack_known *skp;
3601 char *rule = vrule;
3602
3603 if (!rule) {
3604 audit_log(actx, GFP_ATOMIC, AUDIT_SELINUX_ERR,
3605 "Smack: missing rule\n");
3606 return -ENOENT;
3607 }
3608
3609 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
3610 return 0;
3611
3612 skp = smack_from_secid(secid);
3613
3614
3615
3616
3617
3618
3619 if (op == Audit_equal)
3620 return (rule == skp->smk_known);
3621 if (op == Audit_not_equal)
3622 return (rule != skp->smk_known);
3623
3624 return 0;
3625}
3626
3627
3628
3629
3630
3631
3632
3633static void smack_audit_rule_free(void *vrule)
3634{
3635
3636}
3637
3638#endif
3639
3640
3641
3642
3643
3644static int smack_ismaclabel(const char *name)
3645{
3646 return (strcmp(name, XATTR_SMACK_SUFFIX) == 0);
3647}
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
3659{
3660 struct smack_known *skp = smack_from_secid(secid);
3661
3662 if (secdata)
3663 *secdata = skp->smk_known;
3664 *seclen = strlen(skp->smk_known);
3665 return 0;
3666}
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
3677{
3678 *secid = smack_to_secid(secdata);
3679 return 0;
3680}
3681
3682
3683
3684
3685
3686
3687
3688
3689static void smack_release_secctx(char *secdata, u32 seclen)
3690{
3691}
3692
3693static int smack_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
3694{
3695 return smack_inode_setsecurity(inode, XATTR_SMACK_SUFFIX, ctx, ctxlen, 0);
3696}
3697
3698static int smack_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
3699{
3700 return __vfs_setxattr_noperm(dentry, XATTR_NAME_SMACK, ctx, ctxlen, 0);
3701}
3702
3703static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
3704{
3705 int len = 0;
3706 len = smack_inode_getsecurity(inode, XATTR_SMACK_SUFFIX, ctx, true);
3707
3708 if (len < 0)
3709 return len;
3710 *ctxlen = len;
3711 return 0;
3712}
3713
3714struct security_operations smack_ops = {
3715 .name = "smack",
3716
3717 .ptrace_access_check = smack_ptrace_access_check,
3718 .ptrace_traceme = smack_ptrace_traceme,
3719 .syslog = smack_syslog,
3720
3721 .sb_alloc_security = smack_sb_alloc_security,
3722 .sb_free_security = smack_sb_free_security,
3723 .sb_copy_data = smack_sb_copy_data,
3724 .sb_kern_mount = smack_sb_kern_mount,
3725 .sb_statfs = smack_sb_statfs,
3726 .sb_mount = smack_sb_mount,
3727 .sb_umount = smack_sb_umount,
3728
3729 .bprm_set_creds = smack_bprm_set_creds,
3730 .bprm_committing_creds = smack_bprm_committing_creds,
3731 .bprm_secureexec = smack_bprm_secureexec,
3732
3733 .inode_alloc_security = smack_inode_alloc_security,
3734 .inode_free_security = smack_inode_free_security,
3735 .inode_init_security = smack_inode_init_security,
3736 .inode_link = smack_inode_link,
3737 .inode_unlink = smack_inode_unlink,
3738 .inode_rmdir = smack_inode_rmdir,
3739 .inode_rename = smack_inode_rename,
3740 .inode_permission = smack_inode_permission,
3741 .inode_setattr = smack_inode_setattr,
3742 .inode_getattr = smack_inode_getattr,
3743 .inode_setxattr = smack_inode_setxattr,
3744 .inode_post_setxattr = smack_inode_post_setxattr,
3745 .inode_getxattr = smack_inode_getxattr,
3746 .inode_removexattr = smack_inode_removexattr,
3747 .inode_getsecurity = smack_inode_getsecurity,
3748 .inode_setsecurity = smack_inode_setsecurity,
3749 .inode_listsecurity = smack_inode_listsecurity,
3750 .inode_getsecid = smack_inode_getsecid,
3751
3752 .file_permission = smack_file_permission,
3753 .file_alloc_security = smack_file_alloc_security,
3754 .file_free_security = smack_file_free_security,
3755 .file_ioctl = smack_file_ioctl,
3756 .file_lock = smack_file_lock,
3757 .file_fcntl = smack_file_fcntl,
3758 .mmap_file = smack_mmap_file,
3759 .mmap_addr = cap_mmap_addr,
3760 .file_set_fowner = smack_file_set_fowner,
3761 .file_send_sigiotask = smack_file_send_sigiotask,
3762 .file_receive = smack_file_receive,
3763
3764 .file_open = smack_file_open,
3765
3766 .cred_alloc_blank = smack_cred_alloc_blank,
3767 .cred_free = smack_cred_free,
3768 .cred_prepare = smack_cred_prepare,
3769 .cred_transfer = smack_cred_transfer,
3770 .kernel_act_as = smack_kernel_act_as,
3771 .kernel_create_files_as = smack_kernel_create_files_as,
3772 .task_setpgid = smack_task_setpgid,
3773 .task_getpgid = smack_task_getpgid,
3774 .task_getsid = smack_task_getsid,
3775 .task_getsecid = smack_task_getsecid,
3776 .task_setnice = smack_task_setnice,
3777 .task_setioprio = smack_task_setioprio,
3778 .task_getioprio = smack_task_getioprio,
3779 .task_setscheduler = smack_task_setscheduler,
3780 .task_getscheduler = smack_task_getscheduler,
3781 .task_movememory = smack_task_movememory,
3782 .task_kill = smack_task_kill,
3783 .task_wait = smack_task_wait,
3784 .task_to_inode = smack_task_to_inode,
3785
3786 .ipc_permission = smack_ipc_permission,
3787 .ipc_getsecid = smack_ipc_getsecid,
3788
3789 .msg_msg_alloc_security = smack_msg_msg_alloc_security,
3790 .msg_msg_free_security = smack_msg_msg_free_security,
3791
3792 .msg_queue_alloc_security = smack_msg_queue_alloc_security,
3793 .msg_queue_free_security = smack_msg_queue_free_security,
3794 .msg_queue_associate = smack_msg_queue_associate,
3795 .msg_queue_msgctl = smack_msg_queue_msgctl,
3796 .msg_queue_msgsnd = smack_msg_queue_msgsnd,
3797 .msg_queue_msgrcv = smack_msg_queue_msgrcv,
3798
3799 .shm_alloc_security = smack_shm_alloc_security,
3800 .shm_free_security = smack_shm_free_security,
3801 .shm_associate = smack_shm_associate,
3802 .shm_shmctl = smack_shm_shmctl,
3803 .shm_shmat = smack_shm_shmat,
3804
3805 .sem_alloc_security = smack_sem_alloc_security,
3806 .sem_free_security = smack_sem_free_security,
3807 .sem_associate = smack_sem_associate,
3808 .sem_semctl = smack_sem_semctl,
3809 .sem_semop = smack_sem_semop,
3810
3811 .d_instantiate = smack_d_instantiate,
3812
3813 .getprocattr = smack_getprocattr,
3814 .setprocattr = smack_setprocattr,
3815
3816 .unix_stream_connect = smack_unix_stream_connect,
3817 .unix_may_send = smack_unix_may_send,
3818
3819 .socket_post_create = smack_socket_post_create,
3820 .socket_bind = smack_socket_bind,
3821 .socket_connect = smack_socket_connect,
3822 .socket_sendmsg = smack_socket_sendmsg,
3823 .socket_sock_rcv_skb = smack_socket_sock_rcv_skb,
3824 .socket_getpeersec_stream = smack_socket_getpeersec_stream,
3825 .socket_getpeersec_dgram = smack_socket_getpeersec_dgram,
3826 .sk_alloc_security = smack_sk_alloc_security,
3827 .sk_free_security = smack_sk_free_security,
3828 .sock_graft = smack_sock_graft,
3829 .inet_conn_request = smack_inet_conn_request,
3830 .inet_csk_clone = smack_inet_csk_clone,
3831
3832
3833#ifdef CONFIG_KEYS
3834 .key_alloc = smack_key_alloc,
3835 .key_free = smack_key_free,
3836 .key_permission = smack_key_permission,
3837#endif
3838
3839
3840#ifdef CONFIG_AUDIT
3841 .audit_rule_init = smack_audit_rule_init,
3842 .audit_rule_known = smack_audit_rule_known,
3843 .audit_rule_match = smack_audit_rule_match,
3844 .audit_rule_free = smack_audit_rule_free,
3845#endif
3846
3847 .ismaclabel = smack_ismaclabel,
3848 .secid_to_secctx = smack_secid_to_secctx,
3849 .secctx_to_secid = smack_secctx_to_secid,
3850 .release_secctx = smack_release_secctx,
3851 .inode_notifysecctx = smack_inode_notifysecctx,
3852 .inode_setsecctx = smack_inode_setsecctx,
3853 .inode_getsecctx = smack_inode_getsecctx,
3854};
3855
3856
3857static __init void init_smack_known_list(void)
3858{
3859
3860
3861
3862 mutex_init(&smack_known_huh.smk_rules_lock);
3863 mutex_init(&smack_known_hat.smk_rules_lock);
3864 mutex_init(&smack_known_floor.smk_rules_lock);
3865 mutex_init(&smack_known_star.smk_rules_lock);
3866 mutex_init(&smack_known_invalid.smk_rules_lock);
3867 mutex_init(&smack_known_web.smk_rules_lock);
3868
3869
3870
3871 INIT_LIST_HEAD(&smack_known_huh.smk_rules);
3872 INIT_LIST_HEAD(&smack_known_hat.smk_rules);
3873 INIT_LIST_HEAD(&smack_known_star.smk_rules);
3874 INIT_LIST_HEAD(&smack_known_floor.smk_rules);
3875 INIT_LIST_HEAD(&smack_known_invalid.smk_rules);
3876 INIT_LIST_HEAD(&smack_known_web.smk_rules);
3877
3878
3879
3880 list_add(&smack_known_huh.list, &smack_known_list);
3881 list_add(&smack_known_hat.list, &smack_known_list);
3882 list_add(&smack_known_star.list, &smack_known_list);
3883 list_add(&smack_known_floor.list, &smack_known_list);
3884 list_add(&smack_known_invalid.list, &smack_known_list);
3885 list_add(&smack_known_web.list, &smack_known_list);
3886}
3887
3888
3889
3890
3891
3892
3893static __init int smack_init(void)
3894{
3895 struct cred *cred;
3896 struct task_smack *tsp;
3897
3898 if (!security_module_enable(&smack_ops))
3899 return 0;
3900
3901 tsp = new_task_smack(&smack_known_floor, &smack_known_floor,
3902 GFP_KERNEL);
3903 if (tsp == NULL)
3904 return -ENOMEM;
3905
3906 printk(KERN_INFO "Smack: Initializing.\n");
3907
3908
3909
3910
3911 cred = (struct cred *) current->cred;
3912 cred->security = tsp;
3913
3914
3915 init_smack_known_list();
3916
3917
3918
3919
3920 if (register_security(&smack_ops))
3921 panic("smack: Unable to register with kernel.\n");
3922
3923 return 0;
3924}
3925
3926
3927
3928
3929
3930security_initcall(smack_init);
3931