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