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