blob: 0278bc08304440df4af600670312e7bd3bce764c [file] [log] [blame]
Casey Schauflere114e472008-02-04 22:29:50 -08001/*
2 * Simplified MAC Kernel (smack) security module
3 *
4 * This file contains the smack hook function implementations.
5 *
6 * Author:
7 * Casey Schaufler <casey@schaufler-ca.com>
8 *
9 * Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2,
13 * as published by the Free Software Foundation.
14 */
15
16#include <linux/xattr.h>
17#include <linux/pagemap.h>
18#include <linux/mount.h>
19#include <linux/stat.h>
20#include <linux/ext2_fs.h>
21#include <linux/kd.h>
22#include <asm/ioctls.h>
23#include <linux/tcp.h>
24#include <linux/udp.h>
25#include <linux/mutex.h>
26#include <linux/pipe_fs_i.h>
27#include <net/netlabel.h>
28#include <net/cipso_ipv4.h>
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +100029#include <linux/audit.h>
Casey Schauflere114e472008-02-04 22:29:50 -080030
31#include "smack.h"
32
David Howellsc69e8d92008-11-14 10:39:19 +110033#define task_security(task) (task_cred_xxx((task), security))
34
Casey Schauflere114e472008-02-04 22:29:50 -080035/*
36 * I hope these are the hokeyist lines of code in the module. Casey.
37 */
38#define DEVPTS_SUPER_MAGIC 0x1cd1
39#define SOCKFS_MAGIC 0x534F434B
40#define TMPFS_MAGIC 0x01021994
41
42/**
43 * smk_fetch - Fetch the smack label from a file.
44 * @ip: a pointer to the inode
45 * @dp: a pointer to the dentry
46 *
47 * Returns a pointer to the master list entry for the Smack label
48 * or NULL if there was no label to fetch.
49 */
50static char *smk_fetch(struct inode *ip, struct dentry *dp)
51{
52 int rc;
53 char in[SMK_LABELLEN];
54
55 if (ip->i_op->getxattr == NULL)
56 return NULL;
57
58 rc = ip->i_op->getxattr(dp, XATTR_NAME_SMACK, in, SMK_LABELLEN);
59 if (rc < 0)
60 return NULL;
61
62 return smk_import(in, rc);
63}
64
65/**
66 * new_inode_smack - allocate an inode security blob
67 * @smack: a pointer to the Smack label to use in the blob
68 *
69 * Returns the new blob or NULL if there's no memory available
70 */
71struct inode_smack *new_inode_smack(char *smack)
72{
73 struct inode_smack *isp;
74
75 isp = kzalloc(sizeof(struct inode_smack), GFP_KERNEL);
76 if (isp == NULL)
77 return NULL;
78
79 isp->smk_inode = smack;
80 isp->smk_flags = 0;
81 mutex_init(&isp->smk_lock);
82
83 return isp;
84}
85
86/*
87 * LSM hooks.
88 * We he, that is fun!
89 */
90
91/**
David Howells5cd9c582008-08-14 11:37:28 +010092 * smack_ptrace_may_access - Smack approval on PTRACE_ATTACH
Casey Schauflere114e472008-02-04 22:29:50 -080093 * @ctp: child task pointer
94 *
95 * Returns 0 if access is OK, an error code otherwise
96 *
97 * Do the capability checks, and require read and write.
98 */
David Howells5cd9c582008-08-14 11:37:28 +010099static int smack_ptrace_may_access(struct task_struct *ctp, unsigned int mode)
Casey Schauflere114e472008-02-04 22:29:50 -0800100{
101 int rc;
102
David Howells5cd9c582008-08-14 11:37:28 +0100103 rc = cap_ptrace_may_access(ctp, mode);
Casey Schauflere114e472008-02-04 22:29:50 -0800104 if (rc != 0)
105 return rc;
106
David Howellsd84f4f92008-11-14 10:39:23 +1100107 rc = smk_access(current_security(), task_security(ctp), MAY_READWRITE);
David Howells5cd9c582008-08-14 11:37:28 +0100108 if (rc != 0 && capable(CAP_MAC_OVERRIDE))
Casey Schauflere114e472008-02-04 22:29:50 -0800109 return 0;
David Howells5cd9c582008-08-14 11:37:28 +0100110 return rc;
111}
Casey Schauflere114e472008-02-04 22:29:50 -0800112
David Howells5cd9c582008-08-14 11:37:28 +0100113/**
114 * smack_ptrace_traceme - Smack approval on PTRACE_TRACEME
115 * @ptp: parent task pointer
116 *
117 * Returns 0 if access is OK, an error code otherwise
118 *
119 * Do the capability checks, and require read and write.
120 */
121static int smack_ptrace_traceme(struct task_struct *ptp)
122{
123 int rc;
124
125 rc = cap_ptrace_traceme(ptp);
126 if (rc != 0)
127 return rc;
128
David Howellsd84f4f92008-11-14 10:39:23 +1100129 rc = smk_access(task_security(ptp), current_security(), MAY_READWRITE);
David Howells5cd9c582008-08-14 11:37:28 +0100130 if (rc != 0 && has_capability(ptp, CAP_MAC_OVERRIDE))
131 return 0;
Casey Schauflere114e472008-02-04 22:29:50 -0800132 return rc;
133}
134
135/**
136 * smack_syslog - Smack approval on syslog
137 * @type: message type
138 *
139 * Require that the task has the floor label
140 *
141 * Returns 0 on success, error code otherwise.
142 */
143static int smack_syslog(int type)
144{
145 int rc;
David Howells86a264a2008-11-14 10:39:18 +1100146 char *sp = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -0800147
148 rc = cap_syslog(type);
149 if (rc != 0)
150 return rc;
151
152 if (capable(CAP_MAC_OVERRIDE))
153 return 0;
154
155 if (sp != smack_known_floor.smk_known)
156 rc = -EACCES;
157
158 return rc;
159}
160
161
162/*
163 * Superblock Hooks.
164 */
165
166/**
167 * smack_sb_alloc_security - allocate a superblock blob
168 * @sb: the superblock getting the blob
169 *
170 * Returns 0 on success or -ENOMEM on error.
171 */
172static int smack_sb_alloc_security(struct super_block *sb)
173{
174 struct superblock_smack *sbsp;
175
176 sbsp = kzalloc(sizeof(struct superblock_smack), GFP_KERNEL);
177
178 if (sbsp == NULL)
179 return -ENOMEM;
180
181 sbsp->smk_root = smack_known_floor.smk_known;
182 sbsp->smk_default = smack_known_floor.smk_known;
183 sbsp->smk_floor = smack_known_floor.smk_known;
184 sbsp->smk_hat = smack_known_hat.smk_known;
185 sbsp->smk_initialized = 0;
186 spin_lock_init(&sbsp->smk_sblock);
187
188 sb->s_security = sbsp;
189
190 return 0;
191}
192
193/**
194 * smack_sb_free_security - free a superblock blob
195 * @sb: the superblock getting the blob
196 *
197 */
198static void smack_sb_free_security(struct super_block *sb)
199{
200 kfree(sb->s_security);
201 sb->s_security = NULL;
202}
203
204/**
205 * smack_sb_copy_data - copy mount options data for processing
206 * @type: file system type
207 * @orig: where to start
208 * @smackopts
209 *
210 * Returns 0 on success or -ENOMEM on error.
211 *
212 * Copy the Smack specific mount options out of the mount
213 * options list.
214 */
Eric Parise0007522008-03-05 10:31:54 -0500215static int smack_sb_copy_data(char *orig, char *smackopts)
Casey Schauflere114e472008-02-04 22:29:50 -0800216{
217 char *cp, *commap, *otheropts, *dp;
218
Casey Schauflere114e472008-02-04 22:29:50 -0800219 otheropts = (char *)get_zeroed_page(GFP_KERNEL);
220 if (otheropts == NULL)
221 return -ENOMEM;
222
223 for (cp = orig, commap = orig; commap != NULL; cp = commap + 1) {
224 if (strstr(cp, SMK_FSDEFAULT) == cp)
225 dp = smackopts;
226 else if (strstr(cp, SMK_FSFLOOR) == cp)
227 dp = smackopts;
228 else if (strstr(cp, SMK_FSHAT) == cp)
229 dp = smackopts;
230 else if (strstr(cp, SMK_FSROOT) == cp)
231 dp = smackopts;
232 else
233 dp = otheropts;
234
235 commap = strchr(cp, ',');
236 if (commap != NULL)
237 *commap = '\0';
238
239 if (*dp != '\0')
240 strcat(dp, ",");
241 strcat(dp, cp);
242 }
243
244 strcpy(orig, otheropts);
245 free_page((unsigned long)otheropts);
246
247 return 0;
248}
249
250/**
251 * smack_sb_kern_mount - Smack specific mount processing
252 * @sb: the file system superblock
James Morris12204e22008-12-19 10:44:42 +1100253 * @flags: the mount flags
Casey Schauflere114e472008-02-04 22:29:50 -0800254 * @data: the smack mount options
255 *
256 * Returns 0 on success, an error code on failure
257 */
James Morris12204e22008-12-19 10:44:42 +1100258static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
Casey Schauflere114e472008-02-04 22:29:50 -0800259{
260 struct dentry *root = sb->s_root;
261 struct inode *inode = root->d_inode;
262 struct superblock_smack *sp = sb->s_security;
263 struct inode_smack *isp;
264 char *op;
265 char *commap;
266 char *nsp;
267
268 spin_lock(&sp->smk_sblock);
269 if (sp->smk_initialized != 0) {
270 spin_unlock(&sp->smk_sblock);
271 return 0;
272 }
273 sp->smk_initialized = 1;
274 spin_unlock(&sp->smk_sblock);
275
276 for (op = data; op != NULL; op = commap) {
277 commap = strchr(op, ',');
278 if (commap != NULL)
279 *commap++ = '\0';
280
281 if (strncmp(op, SMK_FSHAT, strlen(SMK_FSHAT)) == 0) {
282 op += strlen(SMK_FSHAT);
283 nsp = smk_import(op, 0);
284 if (nsp != NULL)
285 sp->smk_hat = nsp;
286 } else if (strncmp(op, SMK_FSFLOOR, strlen(SMK_FSFLOOR)) == 0) {
287 op += strlen(SMK_FSFLOOR);
288 nsp = smk_import(op, 0);
289 if (nsp != NULL)
290 sp->smk_floor = nsp;
291 } else if (strncmp(op, SMK_FSDEFAULT,
292 strlen(SMK_FSDEFAULT)) == 0) {
293 op += strlen(SMK_FSDEFAULT);
294 nsp = smk_import(op, 0);
295 if (nsp != NULL)
296 sp->smk_default = nsp;
297 } else if (strncmp(op, SMK_FSROOT, strlen(SMK_FSROOT)) == 0) {
298 op += strlen(SMK_FSROOT);
299 nsp = smk_import(op, 0);
300 if (nsp != NULL)
301 sp->smk_root = nsp;
302 }
303 }
304
305 /*
306 * Initialize the root inode.
307 */
308 isp = inode->i_security;
309 if (isp == NULL)
310 inode->i_security = new_inode_smack(sp->smk_root);
311 else
312 isp->smk_inode = sp->smk_root;
313
314 return 0;
315}
316
317/**
318 * smack_sb_statfs - Smack check on statfs
319 * @dentry: identifies the file system in question
320 *
321 * Returns 0 if current can read the floor of the filesystem,
322 * and error code otherwise
323 */
324static int smack_sb_statfs(struct dentry *dentry)
325{
326 struct superblock_smack *sbp = dentry->d_sb->s_security;
327
328 return smk_curacc(sbp->smk_floor, MAY_READ);
329}
330
331/**
332 * smack_sb_mount - Smack check for mounting
333 * @dev_name: unused
334 * @nd: mount point
335 * @type: unused
336 * @flags: unused
337 * @data: unused
338 *
339 * Returns 0 if current can write the floor of the filesystem
340 * being mounted on, an error code otherwise.
341 */
Al Virob5266eb2008-03-22 17:48:24 -0400342static int smack_sb_mount(char *dev_name, struct path *path,
Casey Schauflere114e472008-02-04 22:29:50 -0800343 char *type, unsigned long flags, void *data)
344{
Al Virob5266eb2008-03-22 17:48:24 -0400345 struct superblock_smack *sbp = path->mnt->mnt_sb->s_security;
Casey Schauflere114e472008-02-04 22:29:50 -0800346
347 return smk_curacc(sbp->smk_floor, MAY_WRITE);
348}
349
350/**
351 * smack_sb_umount - Smack check for unmounting
352 * @mnt: file system to unmount
353 * @flags: unused
354 *
355 * Returns 0 if current can write the floor of the filesystem
356 * being unmounted, an error code otherwise.
357 */
358static int smack_sb_umount(struct vfsmount *mnt, int flags)
359{
360 struct superblock_smack *sbp;
361
362 sbp = mnt->mnt_sb->s_security;
363
364 return smk_curacc(sbp->smk_floor, MAY_WRITE);
365}
366
367/*
368 * Inode hooks
369 */
370
371/**
372 * smack_inode_alloc_security - allocate an inode blob
373 * @inode - the inode in need of a blob
374 *
375 * Returns 0 if it gets a blob, -ENOMEM otherwise
376 */
377static int smack_inode_alloc_security(struct inode *inode)
378{
David Howells86a264a2008-11-14 10:39:18 +1100379 inode->i_security = new_inode_smack(current_security());
Casey Schauflere114e472008-02-04 22:29:50 -0800380 if (inode->i_security == NULL)
381 return -ENOMEM;
382 return 0;
383}
384
385/**
386 * smack_inode_free_security - free an inode blob
387 * @inode - the inode with a blob
388 *
389 * Clears the blob pointer in inode
390 */
391static void smack_inode_free_security(struct inode *inode)
392{
393 kfree(inode->i_security);
394 inode->i_security = NULL;
395}
396
397/**
398 * smack_inode_init_security - copy out the smack from an inode
399 * @inode: the inode
400 * @dir: unused
401 * @name: where to put the attribute name
402 * @value: where to put the attribute value
403 * @len: where to put the length of the attribute
404 *
405 * Returns 0 if it all works out, -ENOMEM if there's no memory
406 */
407static int smack_inode_init_security(struct inode *inode, struct inode *dir,
408 char **name, void **value, size_t *len)
409{
410 char *isp = smk_of_inode(inode);
411
412 if (name) {
413 *name = kstrdup(XATTR_SMACK_SUFFIX, GFP_KERNEL);
414 if (*name == NULL)
415 return -ENOMEM;
416 }
417
418 if (value) {
419 *value = kstrdup(isp, GFP_KERNEL);
420 if (*value == NULL)
421 return -ENOMEM;
422 }
423
424 if (len)
425 *len = strlen(isp) + 1;
426
427 return 0;
428}
429
430/**
431 * smack_inode_link - Smack check on link
432 * @old_dentry: the existing object
433 * @dir: unused
434 * @new_dentry: the new object
435 *
436 * Returns 0 if access is permitted, an error code otherwise
437 */
438static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
439 struct dentry *new_dentry)
440{
441 int rc;
442 char *isp;
443
444 isp = smk_of_inode(old_dentry->d_inode);
445 rc = smk_curacc(isp, MAY_WRITE);
446
447 if (rc == 0 && new_dentry->d_inode != NULL) {
448 isp = smk_of_inode(new_dentry->d_inode);
449 rc = smk_curacc(isp, MAY_WRITE);
450 }
451
452 return rc;
453}
454
455/**
456 * smack_inode_unlink - Smack check on inode deletion
457 * @dir: containing directory object
458 * @dentry: file to unlink
459 *
460 * Returns 0 if current can write the containing directory
461 * and the object, error code otherwise
462 */
463static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
464{
465 struct inode *ip = dentry->d_inode;
466 int rc;
467
468 /*
469 * You need write access to the thing you're unlinking
470 */
471 rc = smk_curacc(smk_of_inode(ip), MAY_WRITE);
472 if (rc == 0)
473 /*
474 * You also need write access to the containing directory
475 */
476 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE);
477
478 return rc;
479}
480
481/**
482 * smack_inode_rmdir - Smack check on directory deletion
483 * @dir: containing directory object
484 * @dentry: directory to unlink
485 *
486 * Returns 0 if current can write the containing directory
487 * and the directory, error code otherwise
488 */
489static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
490{
491 int rc;
492
493 /*
494 * You need write access to the thing you're removing
495 */
496 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
497 if (rc == 0)
498 /*
499 * You also need write access to the containing directory
500 */
501 rc = smk_curacc(smk_of_inode(dir), MAY_WRITE);
502
503 return rc;
504}
505
506/**
507 * smack_inode_rename - Smack check on rename
508 * @old_inode: the old directory
509 * @old_dentry: unused
510 * @new_inode: the new directory
511 * @new_dentry: unused
512 *
513 * Read and write access is required on both the old and
514 * new directories.
515 *
516 * Returns 0 if access is permitted, an error code otherwise
517 */
518static int smack_inode_rename(struct inode *old_inode,
519 struct dentry *old_dentry,
520 struct inode *new_inode,
521 struct dentry *new_dentry)
522{
523 int rc;
524 char *isp;
525
526 isp = smk_of_inode(old_dentry->d_inode);
527 rc = smk_curacc(isp, MAY_READWRITE);
528
529 if (rc == 0 && new_dentry->d_inode != NULL) {
530 isp = smk_of_inode(new_dentry->d_inode);
531 rc = smk_curacc(isp, MAY_READWRITE);
532 }
533
534 return rc;
535}
536
537/**
538 * smack_inode_permission - Smack version of permission()
539 * @inode: the inode in question
540 * @mask: the access requested
541 * @nd: unused
542 *
543 * This is the important Smack hook.
544 *
545 * Returns 0 if access is permitted, -EACCES otherwise
546 */
Al Virob77b0642008-07-17 09:37:02 -0400547static int smack_inode_permission(struct inode *inode, int mask)
Casey Schauflere114e472008-02-04 22:29:50 -0800548{
549 /*
550 * No permission to check. Existence test. Yup, it's there.
551 */
552 if (mask == 0)
553 return 0;
554
555 return smk_curacc(smk_of_inode(inode), mask);
556}
557
558/**
559 * smack_inode_setattr - Smack check for setting attributes
560 * @dentry: the object
561 * @iattr: for the force flag
562 *
563 * Returns 0 if access is permitted, an error code otherwise
564 */
565static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
566{
567 /*
568 * Need to allow for clearing the setuid bit.
569 */
570 if (iattr->ia_valid & ATTR_FORCE)
571 return 0;
572
573 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
574}
575
576/**
577 * smack_inode_getattr - Smack check for getting attributes
578 * @mnt: unused
579 * @dentry: the object
580 *
581 * Returns 0 if access is permitted, an error code otherwise
582 */
583static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
584{
585 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ);
586}
587
588/**
589 * smack_inode_setxattr - Smack check for setting xattrs
590 * @dentry: the object
591 * @name: name of the attribute
592 * @value: unused
593 * @size: unused
594 * @flags: unused
595 *
596 * This protects the Smack attribute explicitly.
597 *
598 * Returns 0 if access is permitted, an error code otherwise
599 */
David Howells8f0cfa52008-04-29 00:59:41 -0700600static int smack_inode_setxattr(struct dentry *dentry, const char *name,
601 const void *value, size_t size, int flags)
Casey Schauflere114e472008-02-04 22:29:50 -0800602{
Casey Schauflerbcdca222008-02-23 15:24:04 -0800603 int rc = 0;
Casey Schauflere114e472008-02-04 22:29:50 -0800604
Casey Schauflerbcdca222008-02-23 15:24:04 -0800605 if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
606 strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
607 strcmp(name, XATTR_NAME_SMACKIPOUT) == 0) {
608 if (!capable(CAP_MAC_ADMIN))
609 rc = -EPERM;
610 } else
611 rc = cap_inode_setxattr(dentry, name, value, size, flags);
612
613 if (rc == 0)
614 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
615
616 return rc;
Casey Schauflere114e472008-02-04 22:29:50 -0800617}
618
619/**
620 * smack_inode_post_setxattr - Apply the Smack update approved above
621 * @dentry: object
622 * @name: attribute name
623 * @value: attribute value
624 * @size: attribute size
625 * @flags: unused
626 *
627 * Set the pointer in the inode blob to the entry found
628 * in the master label list.
629 */
David Howells8f0cfa52008-04-29 00:59:41 -0700630static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
631 const void *value, size_t size, int flags)
Casey Schauflere114e472008-02-04 22:29:50 -0800632{
633 struct inode_smack *isp;
634 char *nsp;
635
636 /*
637 * Not SMACK
638 */
639 if (strcmp(name, XATTR_NAME_SMACK))
640 return;
641
642 if (size >= SMK_LABELLEN)
643 return;
644
645 isp = dentry->d_inode->i_security;
646
647 /*
648 * No locking is done here. This is a pointer
649 * assignment.
650 */
651 nsp = smk_import(value, size);
652 if (nsp != NULL)
653 isp->smk_inode = nsp;
654 else
655 isp->smk_inode = smack_known_invalid.smk_known;
656
657 return;
658}
659
660/*
661 * smack_inode_getxattr - Smack check on getxattr
662 * @dentry: the object
663 * @name: unused
664 *
665 * Returns 0 if access is permitted, an error code otherwise
666 */
David Howells8f0cfa52008-04-29 00:59:41 -0700667static int smack_inode_getxattr(struct dentry *dentry, const char *name)
Casey Schauflere114e472008-02-04 22:29:50 -0800668{
669 return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ);
670}
671
672/*
673 * smack_inode_removexattr - Smack check on removexattr
674 * @dentry: the object
675 * @name: name of the attribute
676 *
677 * Removing the Smack attribute requires CAP_MAC_ADMIN
678 *
679 * Returns 0 if access is permitted, an error code otherwise
680 */
David Howells8f0cfa52008-04-29 00:59:41 -0700681static int smack_inode_removexattr(struct dentry *dentry, const char *name)
Casey Schauflere114e472008-02-04 22:29:50 -0800682{
Casey Schauflerbcdca222008-02-23 15:24:04 -0800683 int rc = 0;
Casey Schauflere114e472008-02-04 22:29:50 -0800684
Casey Schauflerbcdca222008-02-23 15:24:04 -0800685 if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
686 strcmp(name, XATTR_NAME_SMACKIPIN) == 0 ||
687 strcmp(name, XATTR_NAME_SMACKIPOUT) == 0) {
688 if (!capable(CAP_MAC_ADMIN))
689 rc = -EPERM;
690 } else
691 rc = cap_inode_removexattr(dentry, name);
692
693 if (rc == 0)
694 rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
695
696 return rc;
Casey Schauflere114e472008-02-04 22:29:50 -0800697}
698
699/**
700 * smack_inode_getsecurity - get smack xattrs
701 * @inode: the object
702 * @name: attribute name
703 * @buffer: where to put the result
704 * @size: size of the buffer
705 * @err: unused
706 *
707 * Returns the size of the attribute or an error code
708 */
709static int smack_inode_getsecurity(const struct inode *inode,
710 const char *name, void **buffer,
711 bool alloc)
712{
713 struct socket_smack *ssp;
714 struct socket *sock;
715 struct super_block *sbp;
716 struct inode *ip = (struct inode *)inode;
717 char *isp;
718 int ilen;
719 int rc = 0;
720
721 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
722 isp = smk_of_inode(inode);
723 ilen = strlen(isp) + 1;
724 *buffer = isp;
725 return ilen;
726 }
727
728 /*
729 * The rest of the Smack xattrs are only on sockets.
730 */
731 sbp = ip->i_sb;
732 if (sbp->s_magic != SOCKFS_MAGIC)
733 return -EOPNOTSUPP;
734
735 sock = SOCKET_I(ip);
Ahmed S. Darwish2e1d1462008-02-13 15:03:34 -0800736 if (sock == NULL || sock->sk == NULL)
Casey Schauflere114e472008-02-04 22:29:50 -0800737 return -EOPNOTSUPP;
738
739 ssp = sock->sk->sk_security;
740
741 if (strcmp(name, XATTR_SMACK_IPIN) == 0)
742 isp = ssp->smk_in;
743 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0)
744 isp = ssp->smk_out;
745 else
746 return -EOPNOTSUPP;
747
748 ilen = strlen(isp) + 1;
749 if (rc == 0) {
750 *buffer = isp;
751 rc = ilen;
752 }
753
754 return rc;
755}
756
757
758/**
759 * smack_inode_listsecurity - list the Smack attributes
760 * @inode: the object
761 * @buffer: where they go
762 * @buffer_size: size of buffer
763 *
764 * Returns 0 on success, -EINVAL otherwise
765 */
766static int smack_inode_listsecurity(struct inode *inode, char *buffer,
767 size_t buffer_size)
768{
769 int len = strlen(XATTR_NAME_SMACK);
770
771 if (buffer != NULL && len <= buffer_size) {
772 memcpy(buffer, XATTR_NAME_SMACK, len);
773 return len;
774 }
775 return -EINVAL;
776}
777
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +1000778/**
779 * smack_inode_getsecid - Extract inode's security id
780 * @inode: inode to extract the info from
781 * @secid: where result will be saved
782 */
783static void smack_inode_getsecid(const struct inode *inode, u32 *secid)
784{
785 struct inode_smack *isp = inode->i_security;
786
787 *secid = smack_to_secid(isp->smk_inode);
788}
789
Casey Schauflere114e472008-02-04 22:29:50 -0800790/*
791 * File Hooks
792 */
793
794/**
795 * smack_file_permission - Smack check on file operations
796 * @file: unused
797 * @mask: unused
798 *
799 * Returns 0
800 *
801 * Should access checks be done on each read or write?
802 * UNICOS and SELinux say yes.
803 * Trusted Solaris, Trusted Irix, and just about everyone else says no.
804 *
805 * I'll say no for now. Smack does not do the frequent
806 * label changing that SELinux does.
807 */
808static int smack_file_permission(struct file *file, int mask)
809{
810 return 0;
811}
812
813/**
814 * smack_file_alloc_security - assign a file security blob
815 * @file: the object
816 *
817 * The security blob for a file is a pointer to the master
818 * label list, so no allocation is done.
819 *
820 * Returns 0
821 */
822static int smack_file_alloc_security(struct file *file)
823{
David Howells86a264a2008-11-14 10:39:18 +1100824 file->f_security = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -0800825 return 0;
826}
827
828/**
829 * smack_file_free_security - clear a file security blob
830 * @file: the object
831 *
832 * The security blob for a file is a pointer to the master
833 * label list, so no memory is freed.
834 */
835static void smack_file_free_security(struct file *file)
836{
837 file->f_security = NULL;
838}
839
840/**
841 * smack_file_ioctl - Smack check on ioctls
842 * @file: the object
843 * @cmd: what to do
844 * @arg: unused
845 *
846 * Relies heavily on the correct use of the ioctl command conventions.
847 *
848 * Returns 0 if allowed, error code otherwise
849 */
850static int smack_file_ioctl(struct file *file, unsigned int cmd,
851 unsigned long arg)
852{
853 int rc = 0;
854
855 if (_IOC_DIR(cmd) & _IOC_WRITE)
856 rc = smk_curacc(file->f_security, MAY_WRITE);
857
858 if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
859 rc = smk_curacc(file->f_security, MAY_READ);
860
861 return rc;
862}
863
864/**
865 * smack_file_lock - Smack check on file locking
866 * @file: the object
867 * @cmd unused
868 *
869 * Returns 0 if current has write access, error code otherwise
870 */
871static int smack_file_lock(struct file *file, unsigned int cmd)
872{
873 return smk_curacc(file->f_security, MAY_WRITE);
874}
875
876/**
877 * smack_file_fcntl - Smack check on fcntl
878 * @file: the object
879 * @cmd: what action to check
880 * @arg: unused
881 *
882 * Returns 0 if current has access, error code otherwise
883 */
884static int smack_file_fcntl(struct file *file, unsigned int cmd,
885 unsigned long arg)
886{
887 int rc;
888
889 switch (cmd) {
890 case F_DUPFD:
891 case F_GETFD:
892 case F_GETFL:
893 case F_GETLK:
894 case F_GETOWN:
895 case F_GETSIG:
896 rc = smk_curacc(file->f_security, MAY_READ);
897 break;
898 case F_SETFD:
899 case F_SETFL:
900 case F_SETLK:
901 case F_SETLKW:
902 case F_SETOWN:
903 case F_SETSIG:
904 rc = smk_curacc(file->f_security, MAY_WRITE);
905 break;
906 default:
907 rc = smk_curacc(file->f_security, MAY_READWRITE);
908 }
909
910 return rc;
911}
912
913/**
914 * smack_file_set_fowner - set the file security blob value
915 * @file: object in question
916 *
917 * Returns 0
918 * Further research may be required on this one.
919 */
920static int smack_file_set_fowner(struct file *file)
921{
David Howells86a264a2008-11-14 10:39:18 +1100922 file->f_security = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -0800923 return 0;
924}
925
926/**
927 * smack_file_send_sigiotask - Smack on sigio
928 * @tsk: The target task
929 * @fown: the object the signal come from
930 * @signum: unused
931 *
932 * Allow a privileged task to get signals even if it shouldn't
933 *
934 * Returns 0 if a subject with the object's smack could
935 * write to the task, an error code otherwise.
936 */
937static int smack_file_send_sigiotask(struct task_struct *tsk,
938 struct fown_struct *fown, int signum)
939{
940 struct file *file;
941 int rc;
942
943 /*
944 * struct fown_struct is never outside the context of a struct file
945 */
946 file = container_of(fown, struct file, f_owner);
David Howellsb6dff3e2008-11-14 10:39:16 +1100947 rc = smk_access(file->f_security, tsk->cred->security, MAY_WRITE);
David Howells5cd9c582008-08-14 11:37:28 +0100948 if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE))
Casey Schauflere114e472008-02-04 22:29:50 -0800949 return 0;
950 return rc;
951}
952
953/**
954 * smack_file_receive - Smack file receive check
955 * @file: the object
956 *
957 * Returns 0 if current has access, error code otherwise
958 */
959static int smack_file_receive(struct file *file)
960{
961 int may = 0;
962
963 /*
964 * This code relies on bitmasks.
965 */
966 if (file->f_mode & FMODE_READ)
967 may = MAY_READ;
968 if (file->f_mode & FMODE_WRITE)
969 may |= MAY_WRITE;
970
971 return smk_curacc(file->f_security, may);
972}
973
974/*
975 * Task hooks
976 */
977
978/**
David Howellsf1752ee2008-11-14 10:39:17 +1100979 * smack_cred_free - "free" task-level security credentials
980 * @cred: the credentials in question
Casey Schauflere114e472008-02-04 22:29:50 -0800981 *
982 * Smack isn't using copies of blobs. Everyone
983 * points to an immutable list. The blobs never go away.
984 * There is no leak here.
985 */
David Howellsf1752ee2008-11-14 10:39:17 +1100986static void smack_cred_free(struct cred *cred)
Casey Schauflere114e472008-02-04 22:29:50 -0800987{
David Howellsf1752ee2008-11-14 10:39:17 +1100988 cred->security = NULL;
Casey Schauflere114e472008-02-04 22:29:50 -0800989}
990
991/**
David Howellsd84f4f92008-11-14 10:39:23 +1100992 * smack_cred_prepare - prepare new set of credentials for modification
993 * @new: the new credentials
994 * @old: the original credentials
995 * @gfp: the atomicity of any memory allocations
996 *
997 * Prepare a new set of credentials for modification.
998 */
999static int smack_cred_prepare(struct cred *new, const struct cred *old,
1000 gfp_t gfp)
1001{
1002 new->security = old->security;
1003 return 0;
1004}
1005
1006/*
1007 * commit new credentials
1008 * @new: the new credentials
1009 * @old: the original credentials
1010 */
1011static void smack_cred_commit(struct cred *new, const struct cred *old)
1012{
1013}
1014
1015/**
David Howells3a3b7ce2008-11-14 10:39:28 +11001016 * smack_kernel_act_as - Set the subjective context in a set of credentials
1017 * @new points to the set of credentials to be modified.
1018 * @secid specifies the security ID to be set
1019 *
1020 * Set the security data for a kernel service.
1021 */
1022static int smack_kernel_act_as(struct cred *new, u32 secid)
1023{
1024 char *smack = smack_from_secid(secid);
1025
1026 if (smack == NULL)
1027 return -EINVAL;
1028
1029 new->security = smack;
1030 return 0;
1031}
1032
1033/**
1034 * smack_kernel_create_files_as - Set the file creation label in a set of creds
1035 * @new points to the set of credentials to be modified
1036 * @inode points to the inode to use as a reference
1037 *
1038 * Set the file creation context in a set of credentials to the same
1039 * as the objective context of the specified inode
1040 */
1041static int smack_kernel_create_files_as(struct cred *new,
1042 struct inode *inode)
1043{
1044 struct inode_smack *isp = inode->i_security;
1045
1046 new->security = isp->smk_inode;
1047 return 0;
1048}
1049
1050/**
Casey Schauflere114e472008-02-04 22:29:50 -08001051 * smack_task_setpgid - Smack check on setting pgid
1052 * @p: the task object
1053 * @pgid: unused
1054 *
1055 * Return 0 if write access is permitted
1056 */
1057static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
1058{
David Howellsc69e8d92008-11-14 10:39:19 +11001059 return smk_curacc(task_security(p), MAY_WRITE);
Casey Schauflere114e472008-02-04 22:29:50 -08001060}
1061
1062/**
1063 * smack_task_getpgid - Smack access check for getpgid
1064 * @p: the object task
1065 *
1066 * Returns 0 if current can read the object task, error code otherwise
1067 */
1068static int smack_task_getpgid(struct task_struct *p)
1069{
David Howellsc69e8d92008-11-14 10:39:19 +11001070 return smk_curacc(task_security(p), MAY_READ);
Casey Schauflere114e472008-02-04 22:29:50 -08001071}
1072
1073/**
1074 * smack_task_getsid - Smack access check for getsid
1075 * @p: the object task
1076 *
1077 * Returns 0 if current can read the object task, error code otherwise
1078 */
1079static int smack_task_getsid(struct task_struct *p)
1080{
David Howellsc69e8d92008-11-14 10:39:19 +11001081 return smk_curacc(task_security(p), MAY_READ);
Casey Schauflere114e472008-02-04 22:29:50 -08001082}
1083
1084/**
1085 * smack_task_getsecid - get the secid of the task
1086 * @p: the object task
1087 * @secid: where to put the result
1088 *
1089 * Sets the secid to contain a u32 version of the smack label.
1090 */
1091static void smack_task_getsecid(struct task_struct *p, u32 *secid)
1092{
David Howellsc69e8d92008-11-14 10:39:19 +11001093 *secid = smack_to_secid(task_security(p));
Casey Schauflere114e472008-02-04 22:29:50 -08001094}
1095
1096/**
1097 * smack_task_setnice - Smack check on setting nice
1098 * @p: the task object
1099 * @nice: unused
1100 *
1101 * Return 0 if write access is permitted
1102 */
1103static int smack_task_setnice(struct task_struct *p, int nice)
1104{
Casey Schauflerbcdca222008-02-23 15:24:04 -08001105 int rc;
1106
1107 rc = cap_task_setnice(p, nice);
1108 if (rc == 0)
David Howellsc69e8d92008-11-14 10:39:19 +11001109 rc = smk_curacc(task_security(p), MAY_WRITE);
Casey Schauflerbcdca222008-02-23 15:24:04 -08001110 return rc;
Casey Schauflere114e472008-02-04 22:29:50 -08001111}
1112
1113/**
1114 * smack_task_setioprio - Smack check on setting ioprio
1115 * @p: the task object
1116 * @ioprio: unused
1117 *
1118 * Return 0 if write access is permitted
1119 */
1120static int smack_task_setioprio(struct task_struct *p, int ioprio)
1121{
Casey Schauflerbcdca222008-02-23 15:24:04 -08001122 int rc;
1123
1124 rc = cap_task_setioprio(p, ioprio);
1125 if (rc == 0)
David Howellsc69e8d92008-11-14 10:39:19 +11001126 rc = smk_curacc(task_security(p), MAY_WRITE);
Casey Schauflerbcdca222008-02-23 15:24:04 -08001127 return rc;
Casey Schauflere114e472008-02-04 22:29:50 -08001128}
1129
1130/**
1131 * smack_task_getioprio - Smack check on reading ioprio
1132 * @p: the task object
1133 *
1134 * Return 0 if read access is permitted
1135 */
1136static int smack_task_getioprio(struct task_struct *p)
1137{
David Howellsc69e8d92008-11-14 10:39:19 +11001138 return smk_curacc(task_security(p), MAY_READ);
Casey Schauflere114e472008-02-04 22:29:50 -08001139}
1140
1141/**
1142 * smack_task_setscheduler - Smack check on setting scheduler
1143 * @p: the task object
1144 * @policy: unused
1145 * @lp: unused
1146 *
1147 * Return 0 if read access is permitted
1148 */
1149static int smack_task_setscheduler(struct task_struct *p, int policy,
1150 struct sched_param *lp)
1151{
Casey Schauflerbcdca222008-02-23 15:24:04 -08001152 int rc;
1153
1154 rc = cap_task_setscheduler(p, policy, lp);
1155 if (rc == 0)
David Howellsc69e8d92008-11-14 10:39:19 +11001156 rc = smk_curacc(task_security(p), MAY_WRITE);
Casey Schauflerbcdca222008-02-23 15:24:04 -08001157 return rc;
Casey Schauflere114e472008-02-04 22:29:50 -08001158}
1159
1160/**
1161 * smack_task_getscheduler - Smack check on reading scheduler
1162 * @p: the task object
1163 *
1164 * Return 0 if read access is permitted
1165 */
1166static int smack_task_getscheduler(struct task_struct *p)
1167{
David Howellsc69e8d92008-11-14 10:39:19 +11001168 return smk_curacc(task_security(p), MAY_READ);
Casey Schauflere114e472008-02-04 22:29:50 -08001169}
1170
1171/**
1172 * smack_task_movememory - Smack check on moving memory
1173 * @p: the task object
1174 *
1175 * Return 0 if write access is permitted
1176 */
1177static int smack_task_movememory(struct task_struct *p)
1178{
David Howellsc69e8d92008-11-14 10:39:19 +11001179 return smk_curacc(task_security(p), MAY_WRITE);
Casey Schauflere114e472008-02-04 22:29:50 -08001180}
1181
1182/**
1183 * smack_task_kill - Smack check on signal delivery
1184 * @p: the task object
1185 * @info: unused
1186 * @sig: unused
1187 * @secid: identifies the smack to use in lieu of current's
1188 *
1189 * Return 0 if write access is permitted
1190 *
1191 * The secid behavior is an artifact of an SELinux hack
1192 * in the USB code. Someday it may go away.
1193 */
1194static int smack_task_kill(struct task_struct *p, struct siginfo *info,
1195 int sig, u32 secid)
1196{
1197 /*
Casey Schauflere114e472008-02-04 22:29:50 -08001198 * Sending a signal requires that the sender
1199 * can write the receiver.
1200 */
1201 if (secid == 0)
David Howellsc69e8d92008-11-14 10:39:19 +11001202 return smk_curacc(task_security(p), MAY_WRITE);
Casey Schauflere114e472008-02-04 22:29:50 -08001203 /*
1204 * If the secid isn't 0 we're dealing with some USB IO
1205 * specific behavior. This is not clean. For one thing
1206 * we can't take privilege into account.
1207 */
David Howellsc69e8d92008-11-14 10:39:19 +11001208 return smk_access(smack_from_secid(secid), task_security(p), MAY_WRITE);
Casey Schauflere114e472008-02-04 22:29:50 -08001209}
1210
1211/**
1212 * smack_task_wait - Smack access check for waiting
1213 * @p: task to wait for
1214 *
1215 * Returns 0 if current can wait for p, error code otherwise
1216 */
1217static int smack_task_wait(struct task_struct *p)
1218{
1219 int rc;
1220
David Howellsc69e8d92008-11-14 10:39:19 +11001221 rc = smk_access(current_security(), task_security(p), MAY_WRITE);
Casey Schauflere114e472008-02-04 22:29:50 -08001222 if (rc == 0)
1223 return 0;
1224
1225 /*
1226 * Allow the operation to succeed if either task
1227 * has privilege to perform operations that might
1228 * account for the smack labels having gotten to
1229 * be different in the first place.
1230 *
David Howells5cd9c582008-08-14 11:37:28 +01001231 * This breaks the strict subject/object access
Casey Schauflere114e472008-02-04 22:29:50 -08001232 * control ideal, taking the object's privilege
1233 * state into account in the decision as well as
1234 * the smack value.
1235 */
David Howells5cd9c582008-08-14 11:37:28 +01001236 if (capable(CAP_MAC_OVERRIDE) || has_capability(p, CAP_MAC_OVERRIDE))
Casey Schauflere114e472008-02-04 22:29:50 -08001237 return 0;
1238
1239 return rc;
1240}
1241
1242/**
1243 * smack_task_to_inode - copy task smack into the inode blob
1244 * @p: task to copy from
1245 * inode: inode to copy to
1246 *
1247 * Sets the smack pointer in the inode security blob
1248 */
1249static void smack_task_to_inode(struct task_struct *p, struct inode *inode)
1250{
1251 struct inode_smack *isp = inode->i_security;
David Howellsc69e8d92008-11-14 10:39:19 +11001252 isp->smk_inode = task_security(p);
Casey Schauflere114e472008-02-04 22:29:50 -08001253}
1254
1255/*
1256 * Socket hooks.
1257 */
1258
1259/**
1260 * smack_sk_alloc_security - Allocate a socket blob
1261 * @sk: the socket
1262 * @family: unused
1263 * @priority: memory allocation priority
1264 *
1265 * Assign Smack pointers to current
1266 *
1267 * Returns 0 on success, -ENOMEM is there's no memory
1268 */
1269static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
1270{
David Howells86a264a2008-11-14 10:39:18 +11001271 char *csp = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08001272 struct socket_smack *ssp;
1273
1274 ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
1275 if (ssp == NULL)
1276 return -ENOMEM;
1277
1278 ssp->smk_in = csp;
1279 ssp->smk_out = csp;
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001280 ssp->smk_labeled = SMACK_CIPSO_SOCKET;
Casey Schauflere114e472008-02-04 22:29:50 -08001281 ssp->smk_packet[0] = '\0';
1282
1283 sk->sk_security = ssp;
1284
1285 return 0;
1286}
1287
1288/**
1289 * smack_sk_free_security - Free a socket blob
1290 * @sk: the socket
1291 *
1292 * Clears the blob pointer
1293 */
1294static void smack_sk_free_security(struct sock *sk)
1295{
1296 kfree(sk->sk_security);
1297}
1298
1299/**
1300 * smack_set_catset - convert a capset to netlabel mls categories
1301 * @catset: the Smack categories
1302 * @sap: where to put the netlabel categories
1303 *
1304 * Allocates and fills attr.mls.cat
1305 */
1306static void smack_set_catset(char *catset, struct netlbl_lsm_secattr *sap)
1307{
1308 unsigned char *cp;
1309 unsigned char m;
1310 int cat;
1311 int rc;
1312 int byte;
1313
Harvey Harrisonc60264c2008-04-28 02:13:41 -07001314 if (!catset)
Casey Schauflere114e472008-02-04 22:29:50 -08001315 return;
1316
1317 sap->flags |= NETLBL_SECATTR_MLS_CAT;
1318 sap->attr.mls.cat = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
1319 sap->attr.mls.cat->startbit = 0;
1320
1321 for (cat = 1, cp = catset, byte = 0; byte < SMK_LABELLEN; cp++, byte++)
1322 for (m = 0x80; m != 0; m >>= 1, cat++) {
1323 if ((m & *cp) == 0)
1324 continue;
1325 rc = netlbl_secattr_catmap_setbit(sap->attr.mls.cat,
1326 cat, GFP_ATOMIC);
1327 }
1328}
1329
1330/**
1331 * smack_to_secattr - fill a secattr from a smack value
1332 * @smack: the smack value
1333 * @nlsp: where the result goes
1334 *
1335 * Casey says that CIPSO is good enough for now.
1336 * It can be used to effect.
1337 * It can also be abused to effect when necessary.
1338 * Appologies to the TSIG group in general and GW in particular.
1339 */
1340static void smack_to_secattr(char *smack, struct netlbl_lsm_secattr *nlsp)
1341{
1342 struct smack_cipso cipso;
1343 int rc;
1344
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001345 nlsp->domain = smack;
1346 nlsp->flags = NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
Casey Schauflere114e472008-02-04 22:29:50 -08001347
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001348 rc = smack_to_cipso(smack, &cipso);
1349 if (rc == 0) {
1350 nlsp->attr.mls.lvl = cipso.smk_level;
1351 smack_set_catset(cipso.smk_catset, nlsp);
1352 } else {
1353 nlsp->attr.mls.lvl = smack_cipso_direct;
1354 smack_set_catset(smack, nlsp);
Casey Schauflere114e472008-02-04 22:29:50 -08001355 }
1356}
1357
1358/**
1359 * smack_netlabel - Set the secattr on a socket
1360 * @sk: the socket
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001361 * @labeled: socket label scheme
Casey Schauflere114e472008-02-04 22:29:50 -08001362 *
1363 * Convert the outbound smack value (smk_out) to a
1364 * secattr and attach it to the socket.
1365 *
1366 * Returns 0 on success or an error code
1367 */
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001368static int smack_netlabel(struct sock *sk, int labeled)
Casey Schauflere114e472008-02-04 22:29:50 -08001369{
Ahmed S. Darwish2e1d1462008-02-13 15:03:34 -08001370 struct socket_smack *ssp;
Casey Schauflere114e472008-02-04 22:29:50 -08001371 struct netlbl_lsm_secattr secattr;
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001372 int rc = 0;
Casey Schauflere114e472008-02-04 22:29:50 -08001373
Ahmed S. Darwish2e1d1462008-02-13 15:03:34 -08001374 ssp = sk->sk_security;
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001375 /*
1376 * Usually the netlabel code will handle changing the
1377 * packet labeling based on the label.
1378 * The case of a single label host is different, because
1379 * a single label host should never get a labeled packet
1380 * even though the label is usually associated with a packet
1381 * label.
1382 */
1383 local_bh_disable();
1384 bh_lock_sock_nested(sk);
1385
1386 if (ssp->smk_out == smack_net_ambient ||
1387 labeled == SMACK_UNLABELED_SOCKET)
1388 netlbl_sock_delattr(sk);
1389 else {
1390 netlbl_secattr_init(&secattr);
1391 smack_to_secattr(ssp->smk_out, &secattr);
1392 rc = netlbl_sock_setattr(sk, &secattr);
1393 netlbl_secattr_destroy(&secattr);
1394 }
1395
1396 bh_unlock_sock(sk);
1397 local_bh_enable();
1398 /*
1399 * Remember the label scheme used so that it is not
1400 * necessary to do the netlabel setting if it has not
1401 * changed the next time through.
1402 *
1403 * The -EDESTADDRREQ case is an indication that there's
1404 * a single level host involved.
1405 */
1406 if (rc == 0)
1407 ssp->smk_labeled = labeled;
Casey Schaufler4bc87e62008-02-15 15:24:25 -08001408
Casey Schauflere114e472008-02-04 22:29:50 -08001409 return rc;
1410}
1411
1412/**
1413 * smack_inode_setsecurity - set smack xattrs
1414 * @inode: the object
1415 * @name: attribute name
1416 * @value: attribute value
1417 * @size: size of the attribute
1418 * @flags: unused
1419 *
1420 * Sets the named attribute in the appropriate blob
1421 *
1422 * Returns 0 on success, or an error code
1423 */
1424static int smack_inode_setsecurity(struct inode *inode, const char *name,
1425 const void *value, size_t size, int flags)
1426{
1427 char *sp;
1428 struct inode_smack *nsp = inode->i_security;
1429 struct socket_smack *ssp;
1430 struct socket *sock;
Casey Schaufler4bc87e62008-02-15 15:24:25 -08001431 int rc = 0;
Casey Schauflere114e472008-02-04 22:29:50 -08001432
1433 if (value == NULL || size > SMK_LABELLEN)
1434 return -EACCES;
1435
1436 sp = smk_import(value, size);
1437 if (sp == NULL)
1438 return -EINVAL;
1439
1440 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
1441 nsp->smk_inode = sp;
1442 return 0;
1443 }
1444 /*
1445 * The rest of the Smack xattrs are only on sockets.
1446 */
1447 if (inode->i_sb->s_magic != SOCKFS_MAGIC)
1448 return -EOPNOTSUPP;
1449
1450 sock = SOCKET_I(inode);
Ahmed S. Darwish2e1d1462008-02-13 15:03:34 -08001451 if (sock == NULL || sock->sk == NULL)
Casey Schauflere114e472008-02-04 22:29:50 -08001452 return -EOPNOTSUPP;
1453
1454 ssp = sock->sk->sk_security;
1455
1456 if (strcmp(name, XATTR_SMACK_IPIN) == 0)
1457 ssp->smk_in = sp;
1458 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
1459 ssp->smk_out = sp;
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001460 rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
Casey Schaufler4bc87e62008-02-15 15:24:25 -08001461 if (rc != 0)
1462 printk(KERN_WARNING "Smack: \"%s\" netlbl error %d.\n",
1463 __func__, -rc);
Casey Schauflere114e472008-02-04 22:29:50 -08001464 } else
1465 return -EOPNOTSUPP;
1466
1467 return 0;
1468}
1469
1470/**
1471 * smack_socket_post_create - finish socket setup
1472 * @sock: the socket
1473 * @family: protocol family
1474 * @type: unused
1475 * @protocol: unused
1476 * @kern: unused
1477 *
1478 * Sets the netlabel information on the socket
1479 *
1480 * Returns 0 on success, and error code otherwise
1481 */
1482static int smack_socket_post_create(struct socket *sock, int family,
1483 int type, int protocol, int kern)
1484{
Ahmed S. Darwish2e1d1462008-02-13 15:03:34 -08001485 if (family != PF_INET || sock->sk == NULL)
Casey Schauflere114e472008-02-04 22:29:50 -08001486 return 0;
1487 /*
1488 * Set the outbound netlbl.
1489 */
Casey Schaufler6d3dc072008-12-31 12:54:12 -05001490 return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
1491}
1492
1493
1494/**
1495 * smack_host_label - check host based restrictions
1496 * @sip: the object end
1497 *
1498 * looks for host based access restrictions
1499 *
1500 * This version will only be appropriate for really small
1501 * sets of single label hosts. Because of the masking
1502 * it cannot shortcut out on the first match. There are
1503 * numerious ways to address the problem, but none of them
1504 * have been applied here.
1505 *
1506 * Returns the label of the far end or NULL if it's not special.
1507 */
1508static char *smack_host_label(struct sockaddr_in *sip)
1509{
1510 struct smk_netlbladdr *snp;
1511 char *bestlabel = NULL;
1512 struct in_addr *siap = &sip->sin_addr;
1513 struct in_addr *liap;
1514 struct in_addr *miap;
1515 struct in_addr bestmask;
1516
1517 if (siap->s_addr == 0)
1518 return NULL;
1519
1520 bestmask.s_addr = 0;
1521
1522 for (snp = smack_netlbladdrs; snp != NULL; snp = snp->smk_next) {
1523 liap = &snp->smk_host.sin_addr;
1524 miap = &snp->smk_mask;
1525 /*
1526 * If the addresses match after applying the list entry mask
1527 * the entry matches the address. If it doesn't move along to
1528 * the next entry.
1529 */
1530 if ((liap->s_addr & miap->s_addr) !=
1531 (siap->s_addr & miap->s_addr))
1532 continue;
1533 /*
1534 * If the list entry mask identifies a single address
1535 * it can't get any more specific.
1536 */
1537 if (miap->s_addr == 0xffffffff)
1538 return snp->smk_label;
1539 /*
1540 * If the list entry mask is less specific than the best
1541 * already found this entry is uninteresting.
1542 */
1543 if ((miap->s_addr | bestmask.s_addr) == bestmask.s_addr)
1544 continue;
1545 /*
1546 * This is better than any entry found so far.
1547 */
1548 bestmask.s_addr = miap->s_addr;
1549 bestlabel = snp->smk_label;
1550 }
1551
1552 return bestlabel;
1553}
1554
1555/**
1556 * smack_socket_connect - connect access check
1557 * @sock: the socket
1558 * @sap: the other end
1559 * @addrlen: size of sap
1560 *
1561 * Verifies that a connection may be possible
1562 *
1563 * Returns 0 on success, and error code otherwise
1564 */
1565static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
1566 int addrlen)
1567{
1568 struct socket_smack *ssp = sock->sk->sk_security;
1569 char *hostsp;
1570 int rc;
1571
1572 if (sock->sk == NULL || sock->sk->sk_family != PF_INET)
1573 return 0;
1574
1575 if (addrlen < sizeof(struct sockaddr_in))
1576 return -EINVAL;
1577
1578 hostsp = smack_host_label((struct sockaddr_in *)sap);
1579 if (hostsp == NULL) {
1580 if (ssp->smk_labeled != SMACK_CIPSO_SOCKET)
1581 return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
1582 return 0;
1583 }
1584
1585 rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE);
1586 if (rc != 0)
1587 return rc;
1588
1589 if (ssp->smk_labeled != SMACK_UNLABELED_SOCKET)
1590 return smack_netlabel(sock->sk, SMACK_UNLABELED_SOCKET);
1591 return 0;
Casey Schauflere114e472008-02-04 22:29:50 -08001592}
1593
1594/**
1595 * smack_flags_to_may - convert S_ to MAY_ values
1596 * @flags: the S_ value
1597 *
1598 * Returns the equivalent MAY_ value
1599 */
1600static int smack_flags_to_may(int flags)
1601{
1602 int may = 0;
1603
1604 if (flags & S_IRUGO)
1605 may |= MAY_READ;
1606 if (flags & S_IWUGO)
1607 may |= MAY_WRITE;
1608 if (flags & S_IXUGO)
1609 may |= MAY_EXEC;
1610
1611 return may;
1612}
1613
1614/**
1615 * smack_msg_msg_alloc_security - Set the security blob for msg_msg
1616 * @msg: the object
1617 *
1618 * Returns 0
1619 */
1620static int smack_msg_msg_alloc_security(struct msg_msg *msg)
1621{
David Howells86a264a2008-11-14 10:39:18 +11001622 msg->security = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08001623 return 0;
1624}
1625
1626/**
1627 * smack_msg_msg_free_security - Clear the security blob for msg_msg
1628 * @msg: the object
1629 *
1630 * Clears the blob pointer
1631 */
1632static void smack_msg_msg_free_security(struct msg_msg *msg)
1633{
1634 msg->security = NULL;
1635}
1636
1637/**
1638 * smack_of_shm - the smack pointer for the shm
1639 * @shp: the object
1640 *
1641 * Returns a pointer to the smack value
1642 */
1643static char *smack_of_shm(struct shmid_kernel *shp)
1644{
1645 return (char *)shp->shm_perm.security;
1646}
1647
1648/**
1649 * smack_shm_alloc_security - Set the security blob for shm
1650 * @shp: the object
1651 *
1652 * Returns 0
1653 */
1654static int smack_shm_alloc_security(struct shmid_kernel *shp)
1655{
1656 struct kern_ipc_perm *isp = &shp->shm_perm;
1657
David Howells86a264a2008-11-14 10:39:18 +11001658 isp->security = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08001659 return 0;
1660}
1661
1662/**
1663 * smack_shm_free_security - Clear the security blob for shm
1664 * @shp: the object
1665 *
1666 * Clears the blob pointer
1667 */
1668static void smack_shm_free_security(struct shmid_kernel *shp)
1669{
1670 struct kern_ipc_perm *isp = &shp->shm_perm;
1671
1672 isp->security = NULL;
1673}
1674
1675/**
1676 * smack_shm_associate - Smack access check for shm
1677 * @shp: the object
1678 * @shmflg: access requested
1679 *
1680 * Returns 0 if current has the requested access, error code otherwise
1681 */
1682static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
1683{
1684 char *ssp = smack_of_shm(shp);
1685 int may;
1686
1687 may = smack_flags_to_may(shmflg);
1688 return smk_curacc(ssp, may);
1689}
1690
1691/**
1692 * smack_shm_shmctl - Smack access check for shm
1693 * @shp: the object
1694 * @cmd: what it wants to do
1695 *
1696 * Returns 0 if current has the requested access, error code otherwise
1697 */
1698static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
1699{
Ahmed S. Darwish1d252fb2008-03-19 17:00:51 -07001700 char *ssp;
Casey Schauflere114e472008-02-04 22:29:50 -08001701 int may;
1702
1703 switch (cmd) {
1704 case IPC_STAT:
1705 case SHM_STAT:
1706 may = MAY_READ;
1707 break;
1708 case IPC_SET:
1709 case SHM_LOCK:
1710 case SHM_UNLOCK:
1711 case IPC_RMID:
1712 may = MAY_READWRITE;
1713 break;
1714 case IPC_INFO:
1715 case SHM_INFO:
1716 /*
1717 * System level information.
1718 */
1719 return 0;
1720 default:
1721 return -EINVAL;
1722 }
1723
Ahmed S. Darwish1d252fb2008-03-19 17:00:51 -07001724 ssp = smack_of_shm(shp);
Casey Schauflere114e472008-02-04 22:29:50 -08001725 return smk_curacc(ssp, may);
1726}
1727
1728/**
1729 * smack_shm_shmat - Smack access for shmat
1730 * @shp: the object
1731 * @shmaddr: unused
1732 * @shmflg: access requested
1733 *
1734 * Returns 0 if current has the requested access, error code otherwise
1735 */
1736static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
1737 int shmflg)
1738{
1739 char *ssp = smack_of_shm(shp);
1740 int may;
1741
1742 may = smack_flags_to_may(shmflg);
1743 return smk_curacc(ssp, may);
1744}
1745
1746/**
1747 * smack_of_sem - the smack pointer for the sem
1748 * @sma: the object
1749 *
1750 * Returns a pointer to the smack value
1751 */
1752static char *smack_of_sem(struct sem_array *sma)
1753{
1754 return (char *)sma->sem_perm.security;
1755}
1756
1757/**
1758 * smack_sem_alloc_security - Set the security blob for sem
1759 * @sma: the object
1760 *
1761 * Returns 0
1762 */
1763static int smack_sem_alloc_security(struct sem_array *sma)
1764{
1765 struct kern_ipc_perm *isp = &sma->sem_perm;
1766
David Howells86a264a2008-11-14 10:39:18 +11001767 isp->security = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08001768 return 0;
1769}
1770
1771/**
1772 * smack_sem_free_security - Clear the security blob for sem
1773 * @sma: the object
1774 *
1775 * Clears the blob pointer
1776 */
1777static void smack_sem_free_security(struct sem_array *sma)
1778{
1779 struct kern_ipc_perm *isp = &sma->sem_perm;
1780
1781 isp->security = NULL;
1782}
1783
1784/**
1785 * smack_sem_associate - Smack access check for sem
1786 * @sma: the object
1787 * @semflg: access requested
1788 *
1789 * Returns 0 if current has the requested access, error code otherwise
1790 */
1791static int smack_sem_associate(struct sem_array *sma, int semflg)
1792{
1793 char *ssp = smack_of_sem(sma);
1794 int may;
1795
1796 may = smack_flags_to_may(semflg);
1797 return smk_curacc(ssp, may);
1798}
1799
1800/**
1801 * smack_sem_shmctl - Smack access check for sem
1802 * @sma: the object
1803 * @cmd: what it wants to do
1804 *
1805 * Returns 0 if current has the requested access, error code otherwise
1806 */
1807static int smack_sem_semctl(struct sem_array *sma, int cmd)
1808{
Ahmed S. Darwish1d252fb2008-03-19 17:00:51 -07001809 char *ssp;
Casey Schauflere114e472008-02-04 22:29:50 -08001810 int may;
1811
1812 switch (cmd) {
1813 case GETPID:
1814 case GETNCNT:
1815 case GETZCNT:
1816 case GETVAL:
1817 case GETALL:
1818 case IPC_STAT:
1819 case SEM_STAT:
1820 may = MAY_READ;
1821 break;
1822 case SETVAL:
1823 case SETALL:
1824 case IPC_RMID:
1825 case IPC_SET:
1826 may = MAY_READWRITE;
1827 break;
1828 case IPC_INFO:
1829 case SEM_INFO:
1830 /*
1831 * System level information
1832 */
1833 return 0;
1834 default:
1835 return -EINVAL;
1836 }
1837
Ahmed S. Darwish1d252fb2008-03-19 17:00:51 -07001838 ssp = smack_of_sem(sma);
Casey Schauflere114e472008-02-04 22:29:50 -08001839 return smk_curacc(ssp, may);
1840}
1841
1842/**
1843 * smack_sem_semop - Smack checks of semaphore operations
1844 * @sma: the object
1845 * @sops: unused
1846 * @nsops: unused
1847 * @alter: unused
1848 *
1849 * Treated as read and write in all cases.
1850 *
1851 * Returns 0 if access is allowed, error code otherwise
1852 */
1853static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
1854 unsigned nsops, int alter)
1855{
1856 char *ssp = smack_of_sem(sma);
1857
1858 return smk_curacc(ssp, MAY_READWRITE);
1859}
1860
1861/**
1862 * smack_msg_alloc_security - Set the security blob for msg
1863 * @msq: the object
1864 *
1865 * Returns 0
1866 */
1867static int smack_msg_queue_alloc_security(struct msg_queue *msq)
1868{
1869 struct kern_ipc_perm *kisp = &msq->q_perm;
1870
David Howells86a264a2008-11-14 10:39:18 +11001871 kisp->security = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08001872 return 0;
1873}
1874
1875/**
1876 * smack_msg_free_security - Clear the security blob for msg
1877 * @msq: the object
1878 *
1879 * Clears the blob pointer
1880 */
1881static void smack_msg_queue_free_security(struct msg_queue *msq)
1882{
1883 struct kern_ipc_perm *kisp = &msq->q_perm;
1884
1885 kisp->security = NULL;
1886}
1887
1888/**
1889 * smack_of_msq - the smack pointer for the msq
1890 * @msq: the object
1891 *
1892 * Returns a pointer to the smack value
1893 */
1894static char *smack_of_msq(struct msg_queue *msq)
1895{
1896 return (char *)msq->q_perm.security;
1897}
1898
1899/**
1900 * smack_msg_queue_associate - Smack access check for msg_queue
1901 * @msq: the object
1902 * @msqflg: access requested
1903 *
1904 * Returns 0 if current has the requested access, error code otherwise
1905 */
1906static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
1907{
1908 char *msp = smack_of_msq(msq);
1909 int may;
1910
1911 may = smack_flags_to_may(msqflg);
1912 return smk_curacc(msp, may);
1913}
1914
1915/**
1916 * smack_msg_queue_msgctl - Smack access check for msg_queue
1917 * @msq: the object
1918 * @cmd: what it wants to do
1919 *
1920 * Returns 0 if current has the requested access, error code otherwise
1921 */
1922static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
1923{
Ahmed S. Darwish1d252fb2008-03-19 17:00:51 -07001924 char *msp;
Casey Schauflere114e472008-02-04 22:29:50 -08001925 int may;
1926
1927 switch (cmd) {
1928 case IPC_STAT:
1929 case MSG_STAT:
1930 may = MAY_READ;
1931 break;
1932 case IPC_SET:
1933 case IPC_RMID:
1934 may = MAY_READWRITE;
1935 break;
1936 case IPC_INFO:
1937 case MSG_INFO:
1938 /*
1939 * System level information
1940 */
1941 return 0;
1942 default:
1943 return -EINVAL;
1944 }
1945
Ahmed S. Darwish1d252fb2008-03-19 17:00:51 -07001946 msp = smack_of_msq(msq);
Casey Schauflere114e472008-02-04 22:29:50 -08001947 return smk_curacc(msp, may);
1948}
1949
1950/**
1951 * smack_msg_queue_msgsnd - Smack access check for msg_queue
1952 * @msq: the object
1953 * @msg: unused
1954 * @msqflg: access requested
1955 *
1956 * Returns 0 if current has the requested access, error code otherwise
1957 */
1958static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
1959 int msqflg)
1960{
1961 char *msp = smack_of_msq(msq);
1962 int rc;
1963
1964 rc = smack_flags_to_may(msqflg);
1965 return smk_curacc(msp, rc);
1966}
1967
1968/**
1969 * smack_msg_queue_msgsnd - Smack access check for msg_queue
1970 * @msq: the object
1971 * @msg: unused
1972 * @target: unused
1973 * @type: unused
1974 * @mode: unused
1975 *
1976 * Returns 0 if current has read and write access, error code otherwise
1977 */
1978static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
1979 struct task_struct *target, long type, int mode)
1980{
1981 char *msp = smack_of_msq(msq);
1982
1983 return smk_curacc(msp, MAY_READWRITE);
1984}
1985
1986/**
1987 * smack_ipc_permission - Smack access for ipc_permission()
1988 * @ipp: the object permissions
1989 * @flag: access requested
1990 *
1991 * Returns 0 if current has read and write access, error code otherwise
1992 */
1993static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
1994{
1995 char *isp = ipp->security;
1996 int may;
1997
1998 may = smack_flags_to_may(flag);
1999 return smk_curacc(isp, may);
2000}
2001
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002002/**
2003 * smack_ipc_getsecid - Extract smack security id
2004 * @ipcp: the object permissions
2005 * @secid: where result will be saved
2006 */
2007static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
2008{
2009 char *smack = ipp->security;
2010
2011 *secid = smack_to_secid(smack);
2012}
2013
Casey Schauflere114e472008-02-04 22:29:50 -08002014/**
2015 * smack_d_instantiate - Make sure the blob is correct on an inode
2016 * @opt_dentry: unused
2017 * @inode: the object
2018 *
2019 * Set the inode's security blob if it hasn't been done already.
2020 */
2021static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
2022{
2023 struct super_block *sbp;
2024 struct superblock_smack *sbsp;
2025 struct inode_smack *isp;
David Howells86a264a2008-11-14 10:39:18 +11002026 char *csp = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08002027 char *fetched;
2028 char *final;
2029 struct dentry *dp;
2030
2031 if (inode == NULL)
2032 return;
2033
2034 isp = inode->i_security;
2035
2036 mutex_lock(&isp->smk_lock);
2037 /*
2038 * If the inode is already instantiated
2039 * take the quick way out
2040 */
2041 if (isp->smk_flags & SMK_INODE_INSTANT)
2042 goto unlockandout;
2043
2044 sbp = inode->i_sb;
2045 sbsp = sbp->s_security;
2046 /*
2047 * We're going to use the superblock default label
2048 * if there's no label on the file.
2049 */
2050 final = sbsp->smk_default;
2051
2052 /*
Casey Schauflere97dcb02008-06-02 10:04:32 -07002053 * If this is the root inode the superblock
2054 * may be in the process of initialization.
2055 * If that is the case use the root value out
2056 * of the superblock.
2057 */
2058 if (opt_dentry->d_parent == opt_dentry) {
2059 isp->smk_inode = sbsp->smk_root;
2060 isp->smk_flags |= SMK_INODE_INSTANT;
2061 goto unlockandout;
2062 }
2063
2064 /*
Casey Schauflere114e472008-02-04 22:29:50 -08002065 * This is pretty hackish.
2066 * Casey says that we shouldn't have to do
2067 * file system specific code, but it does help
2068 * with keeping it simple.
2069 */
2070 switch (sbp->s_magic) {
2071 case SMACK_MAGIC:
2072 /*
2073 * Casey says that it's a little embarassing
2074 * that the smack file system doesn't do
2075 * extended attributes.
2076 */
2077 final = smack_known_star.smk_known;
2078 break;
2079 case PIPEFS_MAGIC:
2080 /*
2081 * Casey says pipes are easy (?)
2082 */
2083 final = smack_known_star.smk_known;
2084 break;
2085 case DEVPTS_SUPER_MAGIC:
2086 /*
2087 * devpts seems content with the label of the task.
2088 * Programs that change smack have to treat the
2089 * pty with respect.
2090 */
2091 final = csp;
2092 break;
2093 case SOCKFS_MAGIC:
2094 /*
2095 * Casey says sockets get the smack of the task.
2096 */
2097 final = csp;
2098 break;
2099 case PROC_SUPER_MAGIC:
2100 /*
2101 * Casey says procfs appears not to care.
2102 * The superblock default suffices.
2103 */
2104 break;
2105 case TMPFS_MAGIC:
2106 /*
2107 * Device labels should come from the filesystem,
2108 * but watch out, because they're volitile,
2109 * getting recreated on every reboot.
2110 */
2111 final = smack_known_star.smk_known;
2112 /*
2113 * No break.
2114 *
2115 * If a smack value has been set we want to use it,
2116 * but since tmpfs isn't giving us the opportunity
2117 * to set mount options simulate setting the
2118 * superblock default.
2119 */
2120 default:
2121 /*
2122 * This isn't an understood special case.
2123 * Get the value from the xattr.
2124 *
2125 * No xattr support means, alas, no SMACK label.
2126 * Use the aforeapplied default.
2127 * It would be curious if the label of the task
2128 * does not match that assigned.
2129 */
2130 if (inode->i_op->getxattr == NULL)
2131 break;
2132 /*
2133 * Get the dentry for xattr.
2134 */
2135 if (opt_dentry == NULL) {
2136 dp = d_find_alias(inode);
2137 if (dp == NULL)
2138 break;
2139 } else {
2140 dp = dget(opt_dentry);
2141 if (dp == NULL)
2142 break;
2143 }
2144
2145 fetched = smk_fetch(inode, dp);
2146 if (fetched != NULL)
2147 final = fetched;
2148
2149 dput(dp);
2150 break;
2151 }
2152
2153 if (final == NULL)
2154 isp->smk_inode = csp;
2155 else
2156 isp->smk_inode = final;
2157
2158 isp->smk_flags |= SMK_INODE_INSTANT;
2159
2160unlockandout:
2161 mutex_unlock(&isp->smk_lock);
2162 return;
2163}
2164
2165/**
2166 * smack_getprocattr - Smack process attribute access
2167 * @p: the object task
2168 * @name: the name of the attribute in /proc/.../attr
2169 * @value: where to put the result
2170 *
2171 * Places a copy of the task Smack into value
2172 *
2173 * Returns the length of the smack label or an error code
2174 */
2175static int smack_getprocattr(struct task_struct *p, char *name, char **value)
2176{
2177 char *cp;
2178 int slen;
2179
2180 if (strcmp(name, "current") != 0)
2181 return -EINVAL;
2182
David Howellsc69e8d92008-11-14 10:39:19 +11002183 cp = kstrdup(task_security(p), GFP_KERNEL);
Casey Schauflere114e472008-02-04 22:29:50 -08002184 if (cp == NULL)
2185 return -ENOMEM;
2186
2187 slen = strlen(cp);
2188 *value = cp;
2189 return slen;
2190}
2191
2192/**
2193 * smack_setprocattr - Smack process attribute setting
2194 * @p: the object task
2195 * @name: the name of the attribute in /proc/.../attr
2196 * @value: the value to set
2197 * @size: the size of the value
2198 *
2199 * Sets the Smack value of the task. Only setting self
2200 * is permitted and only with privilege
2201 *
2202 * Returns the length of the smack label or an error code
2203 */
2204static int smack_setprocattr(struct task_struct *p, char *name,
2205 void *value, size_t size)
2206{
David Howellsd84f4f92008-11-14 10:39:23 +11002207 struct cred *new;
Casey Schauflere114e472008-02-04 22:29:50 -08002208 char *newsmack;
2209
Casey Schauflere114e472008-02-04 22:29:50 -08002210 /*
2211 * Changing another process' Smack value is too dangerous
2212 * and supports no sane use case.
2213 */
2214 if (p != current)
2215 return -EPERM;
2216
David Howells5cd9c582008-08-14 11:37:28 +01002217 if (!capable(CAP_MAC_ADMIN))
2218 return -EPERM;
2219
Casey Schauflere114e472008-02-04 22:29:50 -08002220 if (value == NULL || size == 0 || size >= SMK_LABELLEN)
2221 return -EINVAL;
2222
2223 if (strcmp(name, "current") != 0)
2224 return -EINVAL;
2225
2226 newsmack = smk_import(value, size);
2227 if (newsmack == NULL)
2228 return -EINVAL;
2229
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002230 /*
2231 * No process is ever allowed the web ("@") label.
2232 */
2233 if (newsmack == smack_known_web.smk_known)
2234 return -EPERM;
2235
David Howellsd84f4f92008-11-14 10:39:23 +11002236 new = prepare_creds();
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002237 if (new == NULL)
David Howellsd84f4f92008-11-14 10:39:23 +11002238 return -ENOMEM;
2239 new->security = newsmack;
2240 commit_creds(new);
Casey Schauflere114e472008-02-04 22:29:50 -08002241 return size;
2242}
2243
2244/**
2245 * smack_unix_stream_connect - Smack access on UDS
2246 * @sock: one socket
2247 * @other: the other socket
2248 * @newsk: unused
2249 *
2250 * Return 0 if a subject with the smack of sock could access
2251 * an object with the smack of other, otherwise an error code
2252 */
2253static int smack_unix_stream_connect(struct socket *sock,
2254 struct socket *other, struct sock *newsk)
2255{
2256 struct inode *sp = SOCK_INODE(sock);
2257 struct inode *op = SOCK_INODE(other);
2258
2259 return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_READWRITE);
2260}
2261
2262/**
2263 * smack_unix_may_send - Smack access on UDS
2264 * @sock: one socket
2265 * @other: the other socket
2266 *
2267 * Return 0 if a subject with the smack of sock could access
2268 * an object with the smack of other, otherwise an error code
2269 */
2270static int smack_unix_may_send(struct socket *sock, struct socket *other)
2271{
2272 struct inode *sp = SOCK_INODE(sock);
2273 struct inode *op = SOCK_INODE(other);
2274
2275 return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_WRITE);
2276}
2277
2278/**
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002279 * smack_socket_sendmsg - Smack check based on destination host
2280 * @sock: the socket
2281 * @msghdr: the message
2282 * @size: the size of the message
2283 *
2284 * Return 0 if the current subject can write to the destination
2285 * host. This is only a question if the destination is a single
2286 * label host.
2287 */
2288static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
2289 int size)
2290{
2291 struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;
2292 struct socket_smack *ssp = sock->sk->sk_security;
2293 char *hostsp;
2294 int rc;
2295
2296 /*
2297 * Perfectly reasonable for this to be NULL
2298 */
2299 if (sip == NULL || sip->sin_family != PF_INET)
2300 return 0;
2301
2302 hostsp = smack_host_label(sip);
2303 if (hostsp == NULL) {
2304 if (ssp->smk_labeled != SMACK_CIPSO_SOCKET)
2305 return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2306 return 0;
2307 }
2308
2309 rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE);
2310 if (rc != 0)
2311 return rc;
2312
2313 if (ssp->smk_labeled != SMACK_UNLABELED_SOCKET)
2314 return smack_netlabel(sock->sk, SMACK_UNLABELED_SOCKET);
2315
2316 return 0;
2317
2318}
2319
2320
2321/**
Casey Schauflere114e472008-02-04 22:29:50 -08002322 * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat
2323 * pair to smack
2324 * @sap: netlabel secattr
2325 * @sip: where to put the result
2326 *
2327 * Copies a smack label into sip
2328 */
2329static void smack_from_secattr(struct netlbl_lsm_secattr *sap, char *sip)
2330{
2331 char smack[SMK_LABELLEN];
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002332 char *sp;
Casey Schauflere114e472008-02-04 22:29:50 -08002333 int pcat;
2334
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002335 if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
Casey Schauflere114e472008-02-04 22:29:50 -08002336 /*
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002337 * Looks like a CIPSO packet.
Casey Schauflere114e472008-02-04 22:29:50 -08002338 * If there are flags but no level netlabel isn't
2339 * behaving the way we expect it to.
2340 *
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002341 * Get the categories, if any
Casey Schauflere114e472008-02-04 22:29:50 -08002342 * Without guidance regarding the smack value
2343 * for the packet fall back on the network
2344 * ambient value.
2345 */
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002346 memset(smack, '\0', SMK_LABELLEN);
2347 if ((sap->flags & NETLBL_SECATTR_MLS_CAT) != 0)
2348 for (pcat = -1;;) {
2349 pcat = netlbl_secattr_catmap_walk(
2350 sap->attr.mls.cat, pcat + 1);
2351 if (pcat < 0)
2352 break;
2353 smack_catset_bit(pcat, smack);
2354 }
2355 /*
2356 * If it is CIPSO using smack direct mapping
2357 * we are already done. WeeHee.
2358 */
2359 if (sap->attr.mls.lvl == smack_cipso_direct) {
2360 memcpy(sip, smack, SMK_MAXLEN);
2361 return;
Casey Schauflere114e472008-02-04 22:29:50 -08002362 }
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002363 /*
2364 * Look it up in the supplied table if it is not
2365 * a direct mapping.
2366 */
2367 smack_from_cipso(sap->attr.mls.lvl, smack, sip);
2368 return;
2369 }
2370 if ((sap->flags & NETLBL_SECATTR_SECID) != 0) {
2371 /*
2372 * Looks like a fallback, which gives us a secid.
2373 */
2374 sp = smack_from_secid(sap->attr.secid);
2375 /*
2376 * This has got to be a bug because it is
2377 * impossible to specify a fallback without
2378 * specifying the label, which will ensure
2379 * it has a secid, and the only way to get a
2380 * secid is from a fallback.
2381 */
2382 BUG_ON(sp == NULL);
2383 strncpy(sip, sp, SMK_MAXLEN);
Casey Schauflere114e472008-02-04 22:29:50 -08002384 return;
2385 }
2386 /*
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002387 * Without guidance regarding the smack value
2388 * for the packet fall back on the network
2389 * ambient value.
Casey Schauflere114e472008-02-04 22:29:50 -08002390 */
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002391 strncpy(sip, smack_net_ambient, SMK_MAXLEN);
Casey Schauflere114e472008-02-04 22:29:50 -08002392 return;
2393}
2394
2395/**
2396 * smack_socket_sock_rcv_skb - Smack packet delivery access check
2397 * @sk: socket
2398 * @skb: packet
2399 *
2400 * Returns 0 if the packet should be delivered, an error code otherwise
2401 */
2402static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
2403{
2404 struct netlbl_lsm_secattr secattr;
2405 struct socket_smack *ssp = sk->sk_security;
2406 char smack[SMK_LABELLEN];
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002407 char *csp;
Casey Schauflere114e472008-02-04 22:29:50 -08002408 int rc;
2409
2410 if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2411 return 0;
2412
2413 /*
2414 * Translate what netlabel gave us.
2415 */
Casey Schauflere114e472008-02-04 22:29:50 -08002416 netlbl_secattr_init(&secattr);
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002417
Casey Schauflere114e472008-02-04 22:29:50 -08002418 rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002419 if (rc == 0) {
Casey Schauflere114e472008-02-04 22:29:50 -08002420 smack_from_secattr(&secattr, smack);
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002421 csp = smack;
2422 } else
2423 csp = smack_net_ambient;
2424
Casey Schauflere114e472008-02-04 22:29:50 -08002425 netlbl_secattr_destroy(&secattr);
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002426
Casey Schauflere114e472008-02-04 22:29:50 -08002427 /*
2428 * Receiving a packet requires that the other end
2429 * be able to write here. Read access is not required.
2430 * This is the simplist possible security model
2431 * for networking.
2432 */
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002433 rc = smk_access(csp, ssp->smk_in, MAY_WRITE);
Paul Moorea8134292008-10-10 10:16:31 -04002434 if (rc != 0)
2435 netlbl_skbuff_err(skb, rc, 0);
2436 return rc;
Casey Schauflere114e472008-02-04 22:29:50 -08002437}
2438
2439/**
2440 * smack_socket_getpeersec_stream - pull in packet label
2441 * @sock: the socket
2442 * @optval: user's destination
2443 * @optlen: size thereof
2444 * @len: max thereoe
2445 *
2446 * returns zero on success, an error code otherwise
2447 */
2448static int smack_socket_getpeersec_stream(struct socket *sock,
2449 char __user *optval,
2450 int __user *optlen, unsigned len)
2451{
2452 struct socket_smack *ssp;
2453 int slen;
2454 int rc = 0;
2455
2456 ssp = sock->sk->sk_security;
2457 slen = strlen(ssp->smk_packet) + 1;
2458
2459 if (slen > len)
2460 rc = -ERANGE;
2461 else if (copy_to_user(optval, ssp->smk_packet, slen) != 0)
2462 rc = -EFAULT;
2463
2464 if (put_user(slen, optlen) != 0)
2465 rc = -EFAULT;
2466
2467 return rc;
2468}
2469
2470
2471/**
2472 * smack_socket_getpeersec_dgram - pull in packet label
2473 * @sock: the socket
2474 * @skb: packet data
2475 * @secid: pointer to where to put the secid of the packet
2476 *
2477 * Sets the netlabel socket state on sk from parent
2478 */
2479static int smack_socket_getpeersec_dgram(struct socket *sock,
2480 struct sk_buff *skb, u32 *secid)
2481
2482{
2483 struct netlbl_lsm_secattr secattr;
2484 struct sock *sk;
2485 char smack[SMK_LABELLEN];
2486 int family = PF_INET;
2487 u32 s;
2488 int rc;
2489
2490 /*
2491 * Only works for families with packets.
2492 */
2493 if (sock != NULL) {
2494 sk = sock->sk;
2495 if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2496 return 0;
2497 family = sk->sk_family;
2498 }
2499 /*
2500 * Translate what netlabel gave us.
2501 */
Casey Schauflere114e472008-02-04 22:29:50 -08002502 netlbl_secattr_init(&secattr);
2503 rc = netlbl_skbuff_getattr(skb, family, &secattr);
2504 if (rc == 0)
2505 smack_from_secattr(&secattr, smack);
2506 netlbl_secattr_destroy(&secattr);
2507
2508 /*
2509 * Give up if we couldn't get anything
2510 */
2511 if (rc != 0)
2512 return rc;
2513
2514 s = smack_to_secid(smack);
2515 if (s == 0)
2516 return -EINVAL;
2517
2518 *secid = s;
2519 return 0;
2520}
2521
2522/**
2523 * smack_sock_graft - graft access state between two sockets
2524 * @sk: fresh sock
2525 * @parent: donor socket
2526 *
2527 * Sets the netlabel socket state on sk from parent
2528 */
2529static void smack_sock_graft(struct sock *sk, struct socket *parent)
2530{
2531 struct socket_smack *ssp;
2532 int rc;
2533
2534 if (sk == NULL)
2535 return;
2536
2537 if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
2538 return;
2539
2540 ssp = sk->sk_security;
David Howells86a264a2008-11-14 10:39:18 +11002541 ssp->smk_in = ssp->smk_out = current_security();
Casey Schauflere114e472008-02-04 22:29:50 -08002542 ssp->smk_packet[0] = '\0';
2543
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002544 rc = smack_netlabel(sk, SMACK_CIPSO_SOCKET);
Casey Schaufler4bc87e62008-02-15 15:24:25 -08002545 if (rc != 0)
2546 printk(KERN_WARNING "Smack: \"%s\" netlbl error %d.\n",
2547 __func__, -rc);
Casey Schauflere114e472008-02-04 22:29:50 -08002548}
2549
2550/**
2551 * smack_inet_conn_request - Smack access check on connect
2552 * @sk: socket involved
2553 * @skb: packet
2554 * @req: unused
2555 *
2556 * Returns 0 if a task with the packet label could write to
2557 * the socket, otherwise an error code
2558 */
2559static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
2560 struct request_sock *req)
2561{
2562 struct netlbl_lsm_secattr skb_secattr;
2563 struct socket_smack *ssp = sk->sk_security;
2564 char smack[SMK_LABELLEN];
2565 int rc;
2566
2567 if (skb == NULL)
2568 return -EACCES;
2569
Casey Schauflere114e472008-02-04 22:29:50 -08002570 netlbl_secattr_init(&skb_secattr);
2571 rc = netlbl_skbuff_getattr(skb, sk->sk_family, &skb_secattr);
2572 if (rc == 0)
2573 smack_from_secattr(&skb_secattr, smack);
2574 else
2575 strncpy(smack, smack_known_huh.smk_known, SMK_MAXLEN);
2576 netlbl_secattr_destroy(&skb_secattr);
2577 /*
2578 * Receiving a packet requires that the other end
2579 * be able to write here. Read access is not required.
2580 *
2581 * If the request is successful save the peer's label
2582 * so that SO_PEERCRED can report it.
2583 */
2584 rc = smk_access(smack, ssp->smk_in, MAY_WRITE);
2585 if (rc == 0)
2586 strncpy(ssp->smk_packet, smack, SMK_MAXLEN);
2587
2588 return rc;
2589}
2590
2591/*
2592 * Key management security hooks
2593 *
2594 * Casey has not tested key support very heavily.
2595 * The permission check is most likely too restrictive.
2596 * If you care about keys please have a look.
2597 */
2598#ifdef CONFIG_KEYS
2599
2600/**
2601 * smack_key_alloc - Set the key security blob
2602 * @key: object
David Howellsd84f4f92008-11-14 10:39:23 +11002603 * @cred: the credentials to use
Casey Schauflere114e472008-02-04 22:29:50 -08002604 * @flags: unused
2605 *
2606 * No allocation required
2607 *
2608 * Returns 0
2609 */
David Howellsd84f4f92008-11-14 10:39:23 +11002610static int smack_key_alloc(struct key *key, const struct cred *cred,
Casey Schauflere114e472008-02-04 22:29:50 -08002611 unsigned long flags)
2612{
David Howellsd84f4f92008-11-14 10:39:23 +11002613 key->security = cred->security;
Casey Schauflere114e472008-02-04 22:29:50 -08002614 return 0;
2615}
2616
2617/**
2618 * smack_key_free - Clear the key security blob
2619 * @key: the object
2620 *
2621 * Clear the blob pointer
2622 */
2623static void smack_key_free(struct key *key)
2624{
2625 key->security = NULL;
2626}
2627
2628/*
2629 * smack_key_permission - Smack access on a key
2630 * @key_ref: gets to the object
David Howellsd84f4f92008-11-14 10:39:23 +11002631 * @cred: the credentials to use
Casey Schauflere114e472008-02-04 22:29:50 -08002632 * @perm: unused
2633 *
2634 * Return 0 if the task has read and write to the object,
2635 * an error code otherwise
2636 */
2637static int smack_key_permission(key_ref_t key_ref,
David Howellsd84f4f92008-11-14 10:39:23 +11002638 const struct cred *cred, key_perm_t perm)
Casey Schauflere114e472008-02-04 22:29:50 -08002639{
2640 struct key *keyp;
2641
2642 keyp = key_ref_to_ptr(key_ref);
2643 if (keyp == NULL)
2644 return -EINVAL;
2645 /*
2646 * If the key hasn't been initialized give it access so that
2647 * it may do so.
2648 */
2649 if (keyp->security == NULL)
2650 return 0;
2651 /*
2652 * This should not occur
2653 */
David Howellsd84f4f92008-11-14 10:39:23 +11002654 if (cred->security == NULL)
Casey Schauflere114e472008-02-04 22:29:50 -08002655 return -EACCES;
2656
David Howellsd84f4f92008-11-14 10:39:23 +11002657 return smk_access(cred->security, keyp->security, MAY_READWRITE);
Casey Schauflere114e472008-02-04 22:29:50 -08002658}
2659#endif /* CONFIG_KEYS */
2660
2661/*
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002662 * Smack Audit hooks
2663 *
2664 * Audit requires a unique representation of each Smack specific
2665 * rule. This unique representation is used to distinguish the
2666 * object to be audited from remaining kernel objects and also
2667 * works as a glue between the audit hooks.
2668 *
2669 * Since repository entries are added but never deleted, we'll use
2670 * the smack_known label address related to the given audit rule as
2671 * the needed unique representation. This also better fits the smack
2672 * model where nearly everything is a label.
2673 */
2674#ifdef CONFIG_AUDIT
2675
2676/**
2677 * smack_audit_rule_init - Initialize a smack audit rule
2678 * @field: audit rule fields given from user-space (audit.h)
2679 * @op: required testing operator (=, !=, >, <, ...)
2680 * @rulestr: smack label to be audited
2681 * @vrule: pointer to save our own audit rule representation
2682 *
2683 * Prepare to audit cases where (@field @op @rulestr) is true.
2684 * The label to be audited is created if necessay.
2685 */
2686static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
2687{
2688 char **rule = (char **)vrule;
2689 *rule = NULL;
2690
2691 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
2692 return -EINVAL;
2693
Al Viro5af75d82008-12-16 05:59:26 -05002694 if (op != Audit_equal && op != Audit_not_equal)
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002695 return -EINVAL;
2696
2697 *rule = smk_import(rulestr, 0);
2698
2699 return 0;
2700}
2701
2702/**
2703 * smack_audit_rule_known - Distinguish Smack audit rules
2704 * @krule: rule of interest, in Audit kernel representation format
2705 *
2706 * This is used to filter Smack rules from remaining Audit ones.
2707 * If it's proved that this rule belongs to us, the
2708 * audit_rule_match hook will be called to do the final judgement.
2709 */
2710static int smack_audit_rule_known(struct audit_krule *krule)
2711{
2712 struct audit_field *f;
2713 int i;
2714
2715 for (i = 0; i < krule->field_count; i++) {
2716 f = &krule->fields[i];
2717
2718 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
2719 return 1;
2720 }
2721
2722 return 0;
2723}
2724
2725/**
2726 * smack_audit_rule_match - Audit given object ?
2727 * @secid: security id for identifying the object to test
2728 * @field: audit rule flags given from user-space
2729 * @op: required testing operator
2730 * @vrule: smack internal rule presentation
2731 * @actx: audit context associated with the check
2732 *
2733 * The core Audit hook. It's used to take the decision of
2734 * whether to audit or not to audit a given object.
2735 */
2736static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
2737 struct audit_context *actx)
2738{
2739 char *smack;
2740 char *rule = vrule;
2741
2742 if (!rule) {
2743 audit_log(actx, GFP_KERNEL, AUDIT_SELINUX_ERR,
2744 "Smack: missing rule\n");
2745 return -ENOENT;
2746 }
2747
2748 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
2749 return 0;
2750
2751 smack = smack_from_secid(secid);
2752
2753 /*
2754 * No need to do string comparisons. If a match occurs,
2755 * both pointers will point to the same smack_known
2756 * label.
2757 */
Al Viro5af75d82008-12-16 05:59:26 -05002758 if (op == Audit_equal)
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002759 return (rule == smack);
Al Viro5af75d82008-12-16 05:59:26 -05002760 if (op == Audit_not_equal)
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002761 return (rule != smack);
2762
2763 return 0;
2764}
2765
2766/**
2767 * smack_audit_rule_free - free smack rule representation
2768 * @vrule: rule to be freed.
2769 *
2770 * No memory was allocated.
2771 */
2772static void smack_audit_rule_free(void *vrule)
2773{
2774 /* No-op */
2775}
2776
2777#endif /* CONFIG_AUDIT */
2778
2779/*
Casey Schauflere114e472008-02-04 22:29:50 -08002780 * smack_secid_to_secctx - return the smack label for a secid
2781 * @secid: incoming integer
2782 * @secdata: destination
2783 * @seclen: how long it is
2784 *
2785 * Exists for networking code.
2786 */
2787static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
2788{
2789 char *sp = smack_from_secid(secid);
2790
2791 *secdata = sp;
2792 *seclen = strlen(sp);
2793 return 0;
2794}
2795
2796/*
Casey Schaufler4bc87e62008-02-15 15:24:25 -08002797 * smack_secctx_to_secid - return the secid for a smack label
2798 * @secdata: smack label
2799 * @seclen: how long result is
2800 * @secid: outgoing integer
2801 *
2802 * Exists for audit and networking code.
2803 */
David Howellse52c17642008-04-29 20:52:51 +01002804static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
Casey Schaufler4bc87e62008-02-15 15:24:25 -08002805{
2806 *secid = smack_to_secid(secdata);
2807 return 0;
2808}
2809
2810/*
Casey Schauflere114e472008-02-04 22:29:50 -08002811 * smack_release_secctx - don't do anything.
2812 * @key_ref: unused
2813 * @context: unused
2814 * @perm: unused
2815 *
2816 * Exists to make sure nothing gets done, and properly
2817 */
2818static void smack_release_secctx(char *secdata, u32 seclen)
2819{
2820}
2821
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02002822struct security_operations smack_ops = {
2823 .name = "smack",
2824
David Howells5cd9c582008-08-14 11:37:28 +01002825 .ptrace_may_access = smack_ptrace_may_access,
2826 .ptrace_traceme = smack_ptrace_traceme,
Casey Schauflere114e472008-02-04 22:29:50 -08002827 .capget = cap_capget,
David Howellsd84f4f92008-11-14 10:39:23 +11002828 .capset = cap_capset,
Casey Schauflere114e472008-02-04 22:29:50 -08002829 .capable = cap_capable,
2830 .syslog = smack_syslog,
2831 .settime = cap_settime,
2832 .vm_enough_memory = cap_vm_enough_memory,
2833
David Howellsa6f76f22008-11-14 10:39:24 +11002834 .bprm_set_creds = cap_bprm_set_creds,
Casey Schauflere114e472008-02-04 22:29:50 -08002835 .bprm_secureexec = cap_bprm_secureexec,
2836
2837 .sb_alloc_security = smack_sb_alloc_security,
2838 .sb_free_security = smack_sb_free_security,
2839 .sb_copy_data = smack_sb_copy_data,
2840 .sb_kern_mount = smack_sb_kern_mount,
2841 .sb_statfs = smack_sb_statfs,
2842 .sb_mount = smack_sb_mount,
2843 .sb_umount = smack_sb_umount,
2844
2845 .inode_alloc_security = smack_inode_alloc_security,
2846 .inode_free_security = smack_inode_free_security,
2847 .inode_init_security = smack_inode_init_security,
2848 .inode_link = smack_inode_link,
2849 .inode_unlink = smack_inode_unlink,
2850 .inode_rmdir = smack_inode_rmdir,
2851 .inode_rename = smack_inode_rename,
2852 .inode_permission = smack_inode_permission,
2853 .inode_setattr = smack_inode_setattr,
2854 .inode_getattr = smack_inode_getattr,
2855 .inode_setxattr = smack_inode_setxattr,
2856 .inode_post_setxattr = smack_inode_post_setxattr,
2857 .inode_getxattr = smack_inode_getxattr,
2858 .inode_removexattr = smack_inode_removexattr,
Casey Schauflerbcdca222008-02-23 15:24:04 -08002859 .inode_need_killpriv = cap_inode_need_killpriv,
2860 .inode_killpriv = cap_inode_killpriv,
Casey Schauflere114e472008-02-04 22:29:50 -08002861 .inode_getsecurity = smack_inode_getsecurity,
2862 .inode_setsecurity = smack_inode_setsecurity,
2863 .inode_listsecurity = smack_inode_listsecurity,
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002864 .inode_getsecid = smack_inode_getsecid,
Casey Schauflere114e472008-02-04 22:29:50 -08002865
2866 .file_permission = smack_file_permission,
2867 .file_alloc_security = smack_file_alloc_security,
2868 .file_free_security = smack_file_free_security,
2869 .file_ioctl = smack_file_ioctl,
2870 .file_lock = smack_file_lock,
2871 .file_fcntl = smack_file_fcntl,
2872 .file_set_fowner = smack_file_set_fowner,
2873 .file_send_sigiotask = smack_file_send_sigiotask,
2874 .file_receive = smack_file_receive,
2875
David Howellsf1752ee2008-11-14 10:39:17 +11002876 .cred_free = smack_cred_free,
David Howellsd84f4f92008-11-14 10:39:23 +11002877 .cred_prepare = smack_cred_prepare,
2878 .cred_commit = smack_cred_commit,
David Howells3a3b7ce2008-11-14 10:39:28 +11002879 .kernel_act_as = smack_kernel_act_as,
2880 .kernel_create_files_as = smack_kernel_create_files_as,
David Howellsd84f4f92008-11-14 10:39:23 +11002881 .task_fix_setuid = cap_task_fix_setuid,
Casey Schauflere114e472008-02-04 22:29:50 -08002882 .task_setpgid = smack_task_setpgid,
2883 .task_getpgid = smack_task_getpgid,
2884 .task_getsid = smack_task_getsid,
2885 .task_getsecid = smack_task_getsecid,
2886 .task_setnice = smack_task_setnice,
2887 .task_setioprio = smack_task_setioprio,
2888 .task_getioprio = smack_task_getioprio,
2889 .task_setscheduler = smack_task_setscheduler,
2890 .task_getscheduler = smack_task_getscheduler,
2891 .task_movememory = smack_task_movememory,
2892 .task_kill = smack_task_kill,
2893 .task_wait = smack_task_wait,
Casey Schauflere114e472008-02-04 22:29:50 -08002894 .task_to_inode = smack_task_to_inode,
Serge E. Hallyn1236cc32008-04-28 02:13:43 -07002895 .task_prctl = cap_task_prctl,
Casey Schauflere114e472008-02-04 22:29:50 -08002896
2897 .ipc_permission = smack_ipc_permission,
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002898 .ipc_getsecid = smack_ipc_getsecid,
Casey Schauflere114e472008-02-04 22:29:50 -08002899
2900 .msg_msg_alloc_security = smack_msg_msg_alloc_security,
2901 .msg_msg_free_security = smack_msg_msg_free_security,
2902
2903 .msg_queue_alloc_security = smack_msg_queue_alloc_security,
2904 .msg_queue_free_security = smack_msg_queue_free_security,
2905 .msg_queue_associate = smack_msg_queue_associate,
2906 .msg_queue_msgctl = smack_msg_queue_msgctl,
2907 .msg_queue_msgsnd = smack_msg_queue_msgsnd,
2908 .msg_queue_msgrcv = smack_msg_queue_msgrcv,
2909
2910 .shm_alloc_security = smack_shm_alloc_security,
2911 .shm_free_security = smack_shm_free_security,
2912 .shm_associate = smack_shm_associate,
2913 .shm_shmctl = smack_shm_shmctl,
2914 .shm_shmat = smack_shm_shmat,
2915
2916 .sem_alloc_security = smack_sem_alloc_security,
2917 .sem_free_security = smack_sem_free_security,
2918 .sem_associate = smack_sem_associate,
2919 .sem_semctl = smack_sem_semctl,
2920 .sem_semop = smack_sem_semop,
2921
2922 .netlink_send = cap_netlink_send,
2923 .netlink_recv = cap_netlink_recv,
2924
2925 .d_instantiate = smack_d_instantiate,
2926
2927 .getprocattr = smack_getprocattr,
2928 .setprocattr = smack_setprocattr,
2929
2930 .unix_stream_connect = smack_unix_stream_connect,
2931 .unix_may_send = smack_unix_may_send,
2932
2933 .socket_post_create = smack_socket_post_create,
Casey Schaufler6d3dc072008-12-31 12:54:12 -05002934 .socket_connect = smack_socket_connect,
2935 .socket_sendmsg = smack_socket_sendmsg,
Casey Schauflere114e472008-02-04 22:29:50 -08002936 .socket_sock_rcv_skb = smack_socket_sock_rcv_skb,
2937 .socket_getpeersec_stream = smack_socket_getpeersec_stream,
2938 .socket_getpeersec_dgram = smack_socket_getpeersec_dgram,
2939 .sk_alloc_security = smack_sk_alloc_security,
2940 .sk_free_security = smack_sk_free_security,
2941 .sock_graft = smack_sock_graft,
2942 .inet_conn_request = smack_inet_conn_request,
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002943
Casey Schauflere114e472008-02-04 22:29:50 -08002944 /* key management security hooks */
2945#ifdef CONFIG_KEYS
2946 .key_alloc = smack_key_alloc,
2947 .key_free = smack_key_free,
2948 .key_permission = smack_key_permission,
2949#endif /* CONFIG_KEYS */
Ahmed S. Darwishd20bdda2008-04-30 08:34:10 +10002950
2951 /* Audit hooks */
2952#ifdef CONFIG_AUDIT
2953 .audit_rule_init = smack_audit_rule_init,
2954 .audit_rule_known = smack_audit_rule_known,
2955 .audit_rule_match = smack_audit_rule_match,
2956 .audit_rule_free = smack_audit_rule_free,
2957#endif /* CONFIG_AUDIT */
2958
Casey Schauflere114e472008-02-04 22:29:50 -08002959 .secid_to_secctx = smack_secid_to_secctx,
Casey Schaufler4bc87e62008-02-15 15:24:25 -08002960 .secctx_to_secid = smack_secctx_to_secid,
Casey Schauflere114e472008-02-04 22:29:50 -08002961 .release_secctx = smack_release_secctx,
2962};
2963
2964/**
2965 * smack_init - initialize the smack system
2966 *
2967 * Returns 0
2968 */
2969static __init int smack_init(void)
2970{
David Howellsd84f4f92008-11-14 10:39:23 +11002971 struct cred *cred;
2972
Ahmed S. Darwish076c54c2008-03-06 18:09:10 +02002973 if (!security_module_enable(&smack_ops))
2974 return 0;
2975
Casey Schauflere114e472008-02-04 22:29:50 -08002976 printk(KERN_INFO "Smack: Initializing.\n");
2977
2978 /*
2979 * Set the security state for the initial task.
2980 */
David Howellsd84f4f92008-11-14 10:39:23 +11002981 cred = (struct cred *) current->cred;
2982 cred->security = &smack_known_floor.smk_known;
Casey Schauflere114e472008-02-04 22:29:50 -08002983
2984 /*
2985 * Initialize locks
2986 */
Casey Schauflere114e472008-02-04 22:29:50 -08002987 spin_lock_init(&smack_known_huh.smk_cipsolock);
2988 spin_lock_init(&smack_known_hat.smk_cipsolock);
2989 spin_lock_init(&smack_known_star.smk_cipsolock);
2990 spin_lock_init(&smack_known_floor.smk_cipsolock);
2991 spin_lock_init(&smack_known_invalid.smk_cipsolock);
2992
2993 /*
2994 * Register with LSM
2995 */
2996 if (register_security(&smack_ops))
2997 panic("smack: Unable to register with kernel.\n");
2998
2999 return 0;
3000}
3001
3002/*
3003 * Smack requires early initialization in order to label
3004 * all processes and objects when they are created.
3005 */
3006security_initcall(smack_init);