projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'mvebu-dt-4.19-1' of git://git.infradead.org/linux-mvebu into next/dt
[linux-block.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;
7b4e8843 2299 isp->smk_flags |= SMK_INODE_INSTANT;
e114e473
CS		 2300}
2301
2302/*
2303 * Socket hooks.
2304 */
2305
2306/**
2307 * smack_sk_alloc_security - Allocate a socket blob
2308 * @sk: the socket
2309 * @family: unused
251a2a95 2310 * @gfp_flags: memory allocation flags
e114e473
CS		 2311 *
2312 * Assign Smack pointers to current
2313 *
2314 * Returns 0 on success, -ENOMEM is there's no memory
2315 */
2316static int smack_sk_alloc_security(struct sock *sk, int family, gfp_t gfp_flags)
2317{
2f823ff8 2318 struct smack_known *skp = smk_of_current();
e114e473
CS		 2319 struct socket_smack *ssp;
2320
2321 ssp = kzalloc(sizeof(struct socket_smack), gfp_flags);
2322 if (ssp == NULL)
2323 return -ENOMEM;
2324
08382c9f 2325 /*
2326 * Sockets created by kernel threads receive web label.
2327 */
2328 if (unlikely(current->flags & PF_KTHREAD)) {
2329 ssp->smk_in = &smack_known_web;
2330 ssp->smk_out = &smack_known_web;
2331 } else {
2332 ssp->smk_in = skp;
2333 ssp->smk_out = skp;
2334 }
272cd7a8 2335 ssp->smk_packet = NULL;
e114e473
CS		 2336
2337 sk->sk_security = ssp;
2338
2339 return 0;
2340}
2341
2342/**
2343 * smack_sk_free_security - Free a socket blob
2344 * @sk: the socket
2345 *
2346 * Clears the blob pointer
2347 */
2348static void smack_sk_free_security(struct sock *sk)
2349{
0c96d1f5
VG		 2350#ifdef SMACK_IPV6_PORT_LABELING
2351 struct smk_port_label *spp;
2352
2353 if (sk->sk_family == PF_INET6) {
2354 rcu_read_lock();
2355 list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
2356 if (spp->smk_sock != sk)
2357 continue;
2358 spp->smk_can_reuse = 1;
2359 break;
2360 }
2361 rcu_read_unlock();
2362 }
2363#endif
e114e473
CS		 2364 kfree(sk->sk_security);
2365}
2366
07feee8f 2367/**
21abb1ec 2368* smack_ipv4host_label - check host based restrictions
07feee8f
PM		 2369* @sip: the object end
2370*
2371* looks for host based access restrictions
2372*
2373* This version will only be appropriate for really small sets of single label
2374* hosts. The caller is responsible for ensuring that the RCU read lock is
2375* taken before calling this function.
2376*
2377* Returns the label of the far end or NULL if it's not special.
2378*/
21abb1ec 2379static struct smack_known *smack_ipv4host_label(struct sockaddr_in *sip)
07feee8f 2380{
21abb1ec 2381 struct smk_net4addr *snp;
07feee8f
PM		 2382 struct in_addr *siap = &sip->sin_addr;
2383
2384 if (siap->s_addr == 0)
2385 return NULL;
2386
21abb1ec
CS		 2387 list_for_each_entry_rcu(snp, &smk_net4addr_list, list)
2388 /*
2389 * we break after finding the first match because
2390 * the list is sorted from longest to shortest mask
2391 * so we have found the most specific match
2392 */
2393 if (snp->smk_host.s_addr ==
2394 (siap->s_addr & snp->smk_mask.s_addr))
2395 return snp->smk_label;
2396
2397 return NULL;
2398}
2399
2400#if IS_ENABLED(CONFIG_IPV6)
2401/*
2402 * smk_ipv6_localhost - Check for local ipv6 host address
2403 * @sip: the address
2404 *
2405 * Returns boolean true if this is the localhost address
2406 */
2407static bool smk_ipv6_localhost(struct sockaddr_in6 *sip)
2408{
2409 __be16 *be16p = (__be16 *)&sip->sin6_addr;
2410 __be32 *be32p = (__be32 *)&sip->sin6_addr;
2411
2412 if (be32p[0] == 0 && be32p[1] == 0 && be32p[2] == 0 && be16p[6] == 0 &&
2413 ntohs(be16p[7]) == 1)
2414 return true;
2415 return false;
2416}
2417
2418/**
2419* smack_ipv6host_label - check host based restrictions
2420* @sip: the object end
2421*
2422* looks for host based access restrictions
2423*
2424* This version will only be appropriate for really small sets of single label
2425* hosts. The caller is responsible for ensuring that the RCU read lock is
2426* taken before calling this function.
2427*
2428* Returns the label of the far end or NULL if it's not special.
2429*/
2430static struct smack_known *smack_ipv6host_label(struct sockaddr_in6 *sip)
2431{
2432 struct smk_net6addr *snp;
2433 struct in6_addr *sap = &sip->sin6_addr;
2434 int i;
2435 int found = 0;
2436
2437 /*
2438 * It's local. Don't look for a host label.
2439 */
2440 if (smk_ipv6_localhost(sip))
2441 return NULL;
2442
2443 list_for_each_entry_rcu(snp, &smk_net6addr_list, list) {
2e4939f7
CS		 2444 /*
2445 * If the label is NULL the entry has
2446 * been renounced. Ignore it.
2447 */
2448 if (snp->smk_label == NULL)
2449 continue;
07feee8f
PM		 2450 /*
2451 * we break after finding the first match because
2452 * the list is sorted from longest to shortest mask
2453 * so we have found the most specific match
2454 */
21abb1ec 2455 for (found = 1, i = 0; i < 8; i++) {
21abb1ec
CS		 2456 if ((sap->s6_addr16[i] & snp->smk_mask.s6_addr16[i]) !=
2457 snp->smk_host.s6_addr16[i]) {
2458 found = 0;
2459 break;
2460 }
4303154e 2461 }
21abb1ec
CS		 2462 if (found)
2463 return snp->smk_label;
2464 }
07feee8f
PM		 2465
2466 return NULL;
2467}
21abb1ec 2468#endif /* CONFIG_IPV6 */
07feee8f 2469
e114e473
CS		 2470/**
2471 * smack_netlabel - Set the secattr on a socket
2472 * @sk: the socket
6d3dc07c 2473 * @labeled: socket label scheme
e114e473
CS		 2474 *
2475 * Convert the outbound smack value (smk_out) to a
2476 * secattr and attach it to the socket.
2477 *
2478 * Returns 0 on success or an error code
2479 */
6d3dc07c 2480static int smack_netlabel(struct sock *sk, int labeled)
e114e473 2481{
f7112e6c 2482 struct smack_known *skp;
07feee8f 2483 struct socket_smack *ssp = sk->sk_security;
6d3dc07c 2484 int rc = 0;
e114e473 2485
6d3dc07c
CS		 2486 /*
2487 * Usually the netlabel code will handle changing the
2488 * packet labeling based on the label.
2489 * The case of a single label host is different, because
2490 * a single label host should never get a labeled packet
2491 * even though the label is usually associated with a packet
2492 * label.
2493 */
2494 local_bh_disable();
2495 bh_lock_sock_nested(sk);
2496
2497 if (ssp->smk_out == smack_net_ambient ||
2498 labeled == SMACK_UNLABELED_SOCKET)
2499 netlbl_sock_delattr(sk);
2500 else {
2f823ff8 2501 skp = ssp->smk_out;
f7112e6c 2502 rc = netlbl_sock_setattr(sk, sk->sk_family, &skp->smk_netlabel);
6d3dc07c
CS		 2503 }
2504
2505 bh_unlock_sock(sk);
2506 local_bh_enable();
4bc87e62 2507
e114e473
CS		 2508 return rc;
2509}
2510
07feee8f
PM		 2511/**
2512 * smack_netlbel_send - Set the secattr on a socket and perform access checks
2513 * @sk: the socket
2514 * @sap: the destination address
2515 *
2516 * Set the correct secattr for the given socket based on the destination
2517 * address and perform any outbound access checks needed.
2518 *
2519 * Returns 0 on success or an error code.
2520 *
2521 */
2522static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
2523{
2f823ff8 2524 struct smack_known *skp;
07feee8f
PM		 2525 int rc;
2526 int sk_lbl;
21c7eae2 2527 struct smack_known *hkp;
07feee8f 2528 struct socket_smack *ssp = sk->sk_security;
ecfcc53f 2529 struct smk_audit_info ad;
07feee8f
PM		 2530
2531 rcu_read_lock();
21abb1ec 2532 hkp = smack_ipv4host_label(sap);
21c7eae2 2533 if (hkp != NULL) {
ecfcc53f 2534#ifdef CONFIG_AUDIT
923e9a13
KC		 2535 struct lsm_network_audit net;
2536
48c62af6
EP		 2537 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2538 ad.a.u.net->family = sap->sin_family;
2539 ad.a.u.net->dport = sap->sin_port;
2540 ad.a.u.net->v4info.daddr = sap->sin_addr.s_addr;
ecfcc53f 2541#endif
923e9a13 2542 sk_lbl = SMACK_UNLABELED_SOCKET;
2f823ff8 2543 skp = ssp->smk_out;
21c7eae2
LP		 2544 rc = smk_access(skp, hkp, MAY_WRITE, &ad);
2545 rc = smk_bu_note("IPv4 host check", skp, hkp, MAY_WRITE, rc);
07feee8f
PM		 2546 } else {
2547 sk_lbl = SMACK_CIPSO_SOCKET;
2548 rc = 0;
2549 }
2550 rcu_read_unlock();
2551 if (rc != 0)
2552 return rc;
2553
2554 return smack_netlabel(sk, sk_lbl);
2555}
2556
21abb1ec
CS		 2557#if IS_ENABLED(CONFIG_IPV6)
2558/**
2559 * smk_ipv6_check - check Smack access
2560 * @subject: subject Smack label
2561 * @object: object Smack label
2562 * @address: address
2563 * @act: the action being taken
2564 *
2565 * Check an IPv6 access
2566 */
2567static int smk_ipv6_check(struct smack_known *subject,
2568 struct smack_known *object,
2569 struct sockaddr_in6 *address, int act)
2570{
2571#ifdef CONFIG_AUDIT
2572 struct lsm_network_audit net;
2573#endif
2574 struct smk_audit_info ad;
2575 int rc;
2576
2577#ifdef CONFIG_AUDIT
2578 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
2579 ad.a.u.net->family = PF_INET6;
2580 ad.a.u.net->dport = ntohs(address->sin6_port);
2581 if (act == SMK_RECEIVING)
2582 ad.a.u.net->v6info.saddr = address->sin6_addr;
2583 else
2584 ad.a.u.net->v6info.daddr = address->sin6_addr;
2585#endif
2586 rc = smk_access(subject, object, MAY_WRITE, &ad);
2587 rc = smk_bu_note("IPv6 check", subject, object, MAY_WRITE, rc);
2588 return rc;
2589}
2590#endif /* CONFIG_IPV6 */
2591
2592#ifdef SMACK_IPV6_PORT_LABELING
c6739443
CS		 2593/**
2594 * smk_ipv6_port_label - Smack port access table management
2595 * @sock: socket
2596 * @address: address
2597 *
2598 * Create or update the port list entry
2599 */
2600static void smk_ipv6_port_label(struct socket *sock, struct sockaddr *address)
2601{
2602 struct sock *sk = sock->sk;
2603 struct sockaddr_in6 *addr6;
2604 struct socket_smack *ssp = sock->sk->sk_security;
2605 struct smk_port_label *spp;
2606 unsigned short port = 0;
2607
2608 if (address == NULL) {
2609 /*
2610 * This operation is changing the Smack information
2611 * on the bound socket. Take the changes to the port
2612 * as well.
2613 */
3c7ce342
VG		 2614 rcu_read_lock();
2615 list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
c6739443
CS		 2616 if (sk != spp->smk_sock)
2617 continue;
2618 spp->smk_in = ssp->smk_in;
2619 spp->smk_out = ssp->smk_out;
3c7ce342 2620 rcu_read_unlock();
c6739443
CS		 2621 return;
2622 }
2623 /*
2624 * A NULL address is only used for updating existing
2625 * bound entries. If there isn't one, it's OK.
2626 */
3c7ce342 2627 rcu_read_unlock();
c6739443
CS		 2628 return;
2629 }
2630
2631 addr6 = (struct sockaddr_in6 *)address;
2632 port = ntohs(addr6->sin6_port);
2633 /*
2634 * This is a special case that is safely ignored.
2635 */
2636 if (port == 0)
2637 return;
2638
2639 /*
2640 * Look for an existing port list entry.
2641 * This is an indication that a port is getting reused.
2642 */
3c7ce342
VG		 2643 rcu_read_lock();
2644 list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
9d44c973 2645 if (spp->smk_port != port || spp->smk_sock_type != sock->type)
c6739443 2646 continue;
0c96d1f5
VG		 2647 if (spp->smk_can_reuse != 1) {
2648 rcu_read_unlock();
2649 return;
2650 }
c6739443
CS		 2651 spp->smk_port = port;
2652 spp->smk_sock = sk;
2653 spp->smk_in = ssp->smk_in;
2654 spp->smk_out = ssp->smk_out;
0c96d1f5 2655 spp->smk_can_reuse = 0;
3c7ce342 2656 rcu_read_unlock();
c6739443
CS		 2657 return;
2658 }
3c7ce342 2659 rcu_read_unlock();
c6739443
CS		 2660 /*
2661 * A new port entry is required.
2662 */
2663 spp = kzalloc(sizeof(*spp), GFP_KERNEL);
2664 if (spp == NULL)
2665 return;
2666
2667 spp->smk_port = port;
2668 spp->smk_sock = sk;
2669 spp->smk_in = ssp->smk_in;
2670 spp->smk_out = ssp->smk_out;
9d44c973 2671 spp->smk_sock_type = sock->type;
0c96d1f5 2672 spp->smk_can_reuse = 0;
c6739443 2673
3c7ce342
VG		 2674 mutex_lock(&smack_ipv6_lock);
2675 list_add_rcu(&spp->list, &smk_ipv6_port_list);
2676 mutex_unlock(&smack_ipv6_lock);
c6739443
CS		 2677 return;
2678}
2679
2680/**
2681 * smk_ipv6_port_check - check Smack port access
2682 * @sock: socket
2683 * @address: address
2684 *
2685 * Create or update the port list entry
2686 */
6ea06247 2687static int smk_ipv6_port_check(struct sock *sk, struct sockaddr_in6 *address,
c6739443
CS		 2688 int act)
2689{
c6739443
CS		 2690 struct smk_port_label *spp;
2691 struct socket_smack *ssp = sk->sk_security;
21abb1ec
CS		 2692 struct smack_known *skp = NULL;
2693 unsigned short port;
21c7eae2 2694 struct smack_known *object;
c6739443
CS		 2695
2696 if (act == SMK_RECEIVING) {
21abb1ec 2697 skp = smack_ipv6host_label(address);
21c7eae2 2698 object = ssp->smk_in;
c6739443 2699 } else {
2f823ff8 2700 skp = ssp->smk_out;
21abb1ec 2701 object = smack_ipv6host_label(address);
c6739443
CS		 2702 }
2703
2704 /*
21abb1ec 2705 * The other end is a single label host.
c6739443 2706 */
21abb1ec
CS		 2707 if (skp != NULL && object != NULL)
2708 return smk_ipv6_check(skp, object, address, act);
2709 if (skp == NULL)
2710 skp = smack_net_ambient;
2711 if (object == NULL)
2712 object = smack_net_ambient;
c6739443
CS		 2713
2714 /*
2715 * It's remote, so port lookup does no good.
2716 */
21abb1ec
CS		 2717 if (!smk_ipv6_localhost(address))
2718 return smk_ipv6_check(skp, object, address, act);
c6739443
CS		 2719
2720 /*
2721 * It's local so the send check has to have passed.
2722 */
21abb1ec
CS		 2723 if (act == SMK_RECEIVING)
2724 return 0;
c6739443 2725
21abb1ec 2726 port = ntohs(address->sin6_port);
3c7ce342
VG		 2727 rcu_read_lock();
2728 list_for_each_entry_rcu(spp, &smk_ipv6_port_list, list) {
9d44c973 2729 if (spp->smk_port != port || spp->smk_sock_type != sk->sk_type)
c6739443 2730 continue;
21c7eae2 2731 object = spp->smk_in;
c6739443 2732 if (act == SMK_CONNECTING)
54e70ec5 2733 ssp->smk_packet = spp->smk_out;
c6739443
CS		 2734 break;
2735 }
3c7ce342 2736 rcu_read_unlock();
c6739443 2737
21abb1ec 2738 return smk_ipv6_check(skp, object, address, act);
c6739443 2739}
21abb1ec 2740#endif /* SMACK_IPV6_PORT_LABELING */
c6739443 2741
e114e473
CS		 2742/**
2743 * smack_inode_setsecurity - set smack xattrs
2744 * @inode: the object
2745 * @name: attribute name
2746 * @value: attribute value
2747 * @size: size of the attribute
2748 * @flags: unused
2749 *
2750 * Sets the named attribute in the appropriate blob
2751 *
2752 * Returns 0 on success, or an error code
2753 */
2754static int smack_inode_setsecurity(struct inode *inode, const char *name,
2755 const void *value, size_t size, int flags)
2756{
2f823ff8 2757 struct smack_known *skp;
e114e473
CS		 2758 struct inode_smack *nsp = inode->i_security;
2759 struct socket_smack *ssp;
2760 struct socket *sock;
4bc87e62 2761 int rc = 0;
e114e473 2762
f7112e6c 2763 if (value == NULL || size > SMK_LONGLABEL || size == 0)
5e9ab593 2764 return -EINVAL;
e114e473 2765
2f823ff8 2766 skp = smk_import_entry(value, size);
e774ad68
LP		 2767 if (IS_ERR(skp))
2768 return PTR_ERR(skp);
e114e473
CS		 2769
2770 if (strcmp(name, XATTR_SMACK_SUFFIX) == 0) {
21c7eae2 2771 nsp->smk_inode = skp;
ddd29ec6 2772 nsp->smk_flags |= SMK_INODE_INSTANT;
e114e473
CS		 2773 return 0;
2774 }
2775 /*
2776 * The rest of the Smack xattrs are only on sockets.
2777 */
2778 if (inode->i_sb->s_magic != SOCKFS_MAGIC)
2779 return -EOPNOTSUPP;
2780
2781 sock = SOCKET_I(inode);
2e1d146a 2782 if (sock == NULL || sock->sk == NULL)
e114e473
CS		 2783 return -EOPNOTSUPP;
2784
2785 ssp = sock->sk->sk_security;
2786
2787 if (strcmp(name, XATTR_SMACK_IPIN) == 0)
54e70ec5 2788 ssp->smk_in = skp;
e114e473 2789 else if (strcmp(name, XATTR_SMACK_IPOUT) == 0) {
2f823ff8 2790 ssp->smk_out = skp;
c6739443 2791 if (sock->sk->sk_family == PF_INET) {
b4e0d5f0
CS		 2792 rc = smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2793 if (rc != 0)
2794 printk(KERN_WARNING
2795 "Smack: \"%s\" netlbl error %d.\n",
2796 __func__, -rc);
2797 }
e114e473
CS		 2798 } else
2799 return -EOPNOTSUPP;
2800
21abb1ec 2801#ifdef SMACK_IPV6_PORT_LABELING
c6739443
CS		 2802 if (sock->sk->sk_family == PF_INET6)
2803 smk_ipv6_port_label(sock, NULL);
21abb1ec 2804#endif
c6739443 2805
e114e473
CS		 2806 return 0;
2807}
2808
2809/**
2810 * smack_socket_post_create - finish socket setup
2811 * @sock: the socket
2812 * @family: protocol family
2813 * @type: unused
2814 * @protocol: unused
2815 * @kern: unused
2816 *
2817 * Sets the netlabel information on the socket
2818 *
2819 * Returns 0 on success, and error code otherwise
2820 */
2821static int smack_socket_post_create(struct socket *sock, int family,
2822 int type, int protocol, int kern)
2823{
7412301b
ML		 2824 struct socket_smack *ssp;
2825
2826 if (sock->sk == NULL)
2827 return 0;
2828
2829 /*
2830 * Sockets created by kernel threads receive web label.
2831 */
2832 if (unlikely(current->flags & PF_KTHREAD)) {
2833 ssp = sock->sk->sk_security;
2834 ssp->smk_in = &smack_known_web;
2835 ssp->smk_out = &smack_known_web;
2836 }
2837
2838 if (family != PF_INET)
e114e473
CS		 2839 return 0;
2840 /*
2841 * Set the outbound netlbl.
2842 */
6d3dc07c
CS		 2843 return smack_netlabel(sock->sk, SMACK_CIPSO_SOCKET);
2844}
2845
5859cdf5
TG		 2846/**
2847 * smack_socket_socketpair - create socket pair
2848 * @socka: one socket
2849 * @sockb: another socket
2850 *
2851 * Cross reference the peer labels for SO_PEERSEC
2852 *
2853 * Returns 0 on success, and error code otherwise
2854 */
2855static int smack_socket_socketpair(struct socket *socka,
2856 struct socket *sockb)
2857{
2858 struct socket_smack *asp = socka->sk->sk_security;
2859 struct socket_smack *bsp = sockb->sk->sk_security;
2860
2861 asp->smk_packet = bsp->smk_out;
2862 bsp->smk_packet = asp->smk_out;
2863
2864 return 0;
2865}
2866
21abb1ec 2867#ifdef SMACK_IPV6_PORT_LABELING
c6739443
CS		 2868/**
2869 * smack_socket_bind - record port binding information.
2870 * @sock: the socket
2871 * @address: the port address
2872 * @addrlen: size of the address
2873 *
2874 * Records the label bound to a port.
2875 *
2876 * Returns 0
2877 */
2878static int smack_socket_bind(struct socket *sock, struct sockaddr *address,
2879 int addrlen)
2880{
2881 if (sock->sk != NULL && sock->sk->sk_family == PF_INET6)
2882 smk_ipv6_port_label(sock, address);
c6739443
CS		 2883 return 0;
2884}
21abb1ec 2885#endif /* SMACK_IPV6_PORT_LABELING */
c6739443 2886
6d3dc07c
CS		 2887/**
2888 * smack_socket_connect - connect access check
2889 * @sock: the socket
2890 * @sap: the other end
2891 * @addrlen: size of sap
2892 *
2893 * Verifies that a connection may be possible
2894 *
2895 * Returns 0 on success, and error code otherwise
2896 */
2897static int smack_socket_connect(struct socket *sock, struct sockaddr *sap,
2898 int addrlen)
2899{
c6739443 2900 int rc = 0;
21abb1ec
CS		 2901#if IS_ENABLED(CONFIG_IPV6)
2902 struct sockaddr_in6 *sip = (struct sockaddr_in6 *)sap;
2903#endif
2904#ifdef SMACK_IPV6_SECMARK_LABELING
2905 struct smack_known *rsp;
da49b5da 2906 struct socket_smack *ssp;
21abb1ec 2907#endif
c6739443
CS		 2908
2909 if (sock->sk == NULL)
6d3dc07c 2910 return 0;
6d3dc07c 2911
da49b5da
VG		 2912#ifdef SMACK_IPV6_SECMARK_LABELING
2913 ssp = sock->sk->sk_security;
2914#endif
2915
c6739443
CS		 2916 switch (sock->sk->sk_family) {
2917 case PF_INET:
2918 if (addrlen < sizeof(struct sockaddr_in))
2919 return -EINVAL;
2920 rc = smack_netlabel_send(sock->sk, (struct sockaddr_in *)sap);
2921 break;
2922 case PF_INET6:
2923 if (addrlen < sizeof(struct sockaddr_in6))
2924 return -EINVAL;
21abb1ec
CS		 2925#ifdef SMACK_IPV6_SECMARK_LABELING
2926 rsp = smack_ipv6host_label(sip);
2927 if (rsp != NULL)
2928 rc = smk_ipv6_check(ssp->smk_out, rsp, sip,
6ea06247 2929 SMK_CONNECTING);
21abb1ec
CS		 2930#endif
2931#ifdef SMACK_IPV6_PORT_LABELING
2932 rc = smk_ipv6_port_check(sock->sk, sip, SMK_CONNECTING);
2933#endif
c6739443
CS		 2934 break;
2935 }
2936 return rc;
e114e473
CS		 2937}
2938
2939/**
2940 * smack_flags_to_may - convert S_ to MAY_ values
2941 * @flags: the S_ value
2942 *
2943 * Returns the equivalent MAY_ value
2944 */
2945static int smack_flags_to_may(int flags)
2946{
2947 int may = 0;
2948
2949 if (flags & S_IRUGO)
2950 may |= MAY_READ;
2951 if (flags & S_IWUGO)
2952 may |= MAY_WRITE;
2953 if (flags & S_IXUGO)
2954 may |= MAY_EXEC;
2955
2956 return may;
2957}
2958
2959/**
2960 * smack_msg_msg_alloc_security - Set the security blob for msg_msg
2961 * @msg: the object
2962 *
2963 * Returns 0
2964 */
2965static int smack_msg_msg_alloc_security(struct msg_msg *msg)
2966{
2f823ff8
CS		 2967 struct smack_known *skp = smk_of_current();
2968
21c7eae2 2969 msg->security = skp;
e114e473
CS		 2970 return 0;
2971}
2972
2973/**
2974 * smack_msg_msg_free_security - Clear the security blob for msg_msg
2975 * @msg: the object
2976 *
2977 * Clears the blob pointer
2978 */
2979static void smack_msg_msg_free_security(struct msg_msg *msg)
2980{
2981 msg->security = NULL;
2982}
2983
2984/**
0d79cbf8
EB		 2985 * smack_of_ipc - the smack pointer for the ipc
2986 * @isp: the object
e114e473
CS		 2987 *
2988 * Returns a pointer to the smack value
2989 */
0d79cbf8 2990static struct smack_known *smack_of_ipc(struct kern_ipc_perm *isp)
e114e473 2991{
0d79cbf8 2992 return (struct smack_known *)isp->security;
e114e473
CS		 2993}
2994
2995/**
0d79cbf8
EB		 2996 * smack_ipc_alloc_security - Set the security blob for ipc
2997 * @isp: the object
e114e473
CS		 2998 *
2999 * Returns 0
3000 */
0d79cbf8 3001static int smack_ipc_alloc_security(struct kern_ipc_perm *isp)
e114e473 3002{
2f823ff8 3003 struct smack_known *skp = smk_of_current();
e114e473 3004
21c7eae2 3005 isp->security = skp;
e114e473
CS		 3006 return 0;
3007}
3008
3009/**
0d79cbf8
EB		 3010 * smack_ipc_free_security - Clear the security blob for ipc
3011 * @isp: the object
e114e473
CS		 3012 *
3013 * Clears the blob pointer
3014 */
0d79cbf8 3015static void smack_ipc_free_security(struct kern_ipc_perm *isp)
e114e473 3016{
e114e473
CS		 3017 isp->security = NULL;
3018}
3019
ecfcc53f
EB		 3020/**
3021 * smk_curacc_shm : check if current has access on shm
0d79cbf8 3022 * @isp : the object
ecfcc53f
EB		 3023 * @access : access requested
3024 *
3025 * Returns 0 if current has the requested access, error code otherwise
3026 */
0d79cbf8 3027static int smk_curacc_shm(struct kern_ipc_perm *isp, int access)
ecfcc53f 3028{
0d79cbf8 3029 struct smack_known *ssp = smack_of_ipc(isp);
ecfcc53f 3030 struct smk_audit_info ad;
d166c802 3031 int rc;
ecfcc53f
EB		 3032
3033#ifdef CONFIG_AUDIT
3034 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
0d79cbf8 3035 ad.a.u.ipc_id = isp->id;
ecfcc53f 3036#endif
d166c802
CS		 3037 rc = smk_curacc(ssp, access, &ad);
3038 rc = smk_bu_current("shm", ssp, access, rc);
3039 return rc;
ecfcc53f
EB		 3040}
3041
e114e473
CS		 3042/**
3043 * smack_shm_associate - Smack access check for shm
0d79cbf8 3044 * @isp: the object
e114e473
CS		 3045 * @shmflg: access requested
3046 *
3047 * Returns 0 if current has the requested access, error code otherwise
3048 */
0d79cbf8 3049static int smack_shm_associate(struct kern_ipc_perm *isp, int shmflg)
e114e473 3050{
e114e473
CS		 3051 int may;
3052
3053 may = smack_flags_to_may(shmflg);
0d79cbf8 3054 return smk_curacc_shm(isp, may);
e114e473
CS		 3055}
3056
3057/**
3058 * smack_shm_shmctl - Smack access check for shm
0d79cbf8 3059 * @isp: the object
e114e473
CS		 3060 * @cmd: what it wants to do
3061 *
3062 * Returns 0 if current has the requested access, error code otherwise
3063 */
0d79cbf8 3064static int smack_shm_shmctl(struct kern_ipc_perm *isp, int cmd)
e114e473 3065{
e114e473
CS		 3066 int may;
3067
3068 switch (cmd) {
3069 case IPC_STAT:
3070 case SHM_STAT:
c21a6970 3071 case SHM_STAT_ANY:
e114e473
CS		 3072 may = MAY_READ;
3073 break;
3074 case IPC_SET:
3075 case SHM_LOCK:
3076 case SHM_UNLOCK:
3077 case IPC_RMID:
3078 may = MAY_READWRITE;
3079 break;
3080 case IPC_INFO:
3081 case SHM_INFO:
3082 /*
3083 * System level information.
3084 */
3085 return 0;
3086 default:
3087 return -EINVAL;
3088 }
0d79cbf8 3089 return smk_curacc_shm(isp, may);
e114e473
CS		 3090}
3091
3092/**
3093 * smack_shm_shmat - Smack access for shmat
0d79cbf8 3094 * @isp: the object
e114e473
CS		 3095 * @shmaddr: unused
3096 * @shmflg: access requested
3097 *
3098 * Returns 0 if current has the requested access, error code otherwise
3099 */
0d79cbf8 3100static int smack_shm_shmat(struct kern_ipc_perm *ipc, char __user *shmaddr,
e114e473
CS		 3101 int shmflg)
3102{
e114e473
CS		 3103 int may;
3104
3105 may = smack_flags_to_may(shmflg);
0d79cbf8 3106 return smk_curacc_shm(ipc, may);
e114e473
CS		 3107}
3108
ecfcc53f
EB		 3109/**
3110 * smk_curacc_sem : check if current has access on sem
0d79cbf8 3111 * @isp : the object
ecfcc53f
EB		 3112 * @access : access requested
3113 *
3114 * Returns 0 if current has the requested access, error code otherwise
3115 */
0d79cbf8 3116static int smk_curacc_sem(struct kern_ipc_perm *isp, int access)
ecfcc53f 3117{
0d79cbf8 3118 struct smack_known *ssp = smack_of_ipc(isp);
ecfcc53f 3119 struct smk_audit_info ad;
d166c802 3120 int rc;
ecfcc53f
EB		 3121
3122#ifdef CONFIG_AUDIT
3123 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
0d79cbf8 3124 ad.a.u.ipc_id = isp->id;
ecfcc53f 3125#endif
d166c802
CS		 3126 rc = smk_curacc(ssp, access, &ad);
3127 rc = smk_bu_current("sem", ssp, access, rc);
3128 return rc;
ecfcc53f
EB		 3129}
3130
e114e473
CS		 3131/**
3132 * smack_sem_associate - Smack access check for sem
0d79cbf8 3133 * @isp: the object
e114e473
CS		 3134 * @semflg: access requested
3135 *
3136 * Returns 0 if current has the requested access, error code otherwise
3137 */
0d79cbf8 3138static int smack_sem_associate(struct kern_ipc_perm *isp, int semflg)
e114e473 3139{
e114e473
CS		 3140 int may;
3141
3142 may = smack_flags_to_may(semflg);
0d79cbf8 3143 return smk_curacc_sem(isp, may);
e114e473
CS		 3144}
3145
3146/**
3147 * smack_sem_shmctl - Smack access check for sem
0d79cbf8 3148 * @isp: the object
e114e473
CS		 3149 * @cmd: what it wants to do
3150 *
3151 * Returns 0 if current has the requested access, error code otherwise
3152 */
0d79cbf8 3153static int smack_sem_semctl(struct kern_ipc_perm *isp, int cmd)
e114e473 3154{
e114e473
CS		 3155 int may;
3156
3157 switch (cmd) {
3158 case GETPID:
3159 case GETNCNT:
3160 case GETZCNT:
3161 case GETVAL:
3162 case GETALL:
3163 case IPC_STAT:
3164 case SEM_STAT:
a280d6dc 3165 case SEM_STAT_ANY:
e114e473
CS		 3166 may = MAY_READ;
3167 break;
3168 case SETVAL:
3169 case SETALL:
3170 case IPC_RMID:
3171 case IPC_SET:
3172 may = MAY_READWRITE;
3173 break;
3174 case IPC_INFO:
3175 case SEM_INFO:
3176 /*
3177 * System level information
3178 */
3179 return 0;
3180 default:
3181 return -EINVAL;
3182 }
3183
0d79cbf8 3184 return smk_curacc_sem(isp, may);
e114e473
CS		 3185}
3186
3187/**
3188 * smack_sem_semop - Smack checks of semaphore operations
0d79cbf8 3189 * @isp: the object
e114e473
CS		 3190 * @sops: unused
3191 * @nsops: unused
3192 * @alter: unused
3193 *
3194 * Treated as read and write in all cases.
3195 *
3196 * Returns 0 if access is allowed, error code otherwise
3197 */
0d79cbf8 3198static int smack_sem_semop(struct kern_ipc_perm *isp, struct sembuf *sops,
e114e473
CS		 3199 unsigned nsops, int alter)
3200{
0d79cbf8 3201 return smk_curacc_sem(isp, MAY_READWRITE);
e114e473
CS		 3202}
3203
ecfcc53f
EB		 3204/**
3205 * smk_curacc_msq : helper to check if current has access on msq
0d79cbf8 3206 * @isp : the msq
ecfcc53f
EB		 3207 * @access : access requested
3208 *
3209 * return 0 if current has access, error otherwise
3210 */
0d79cbf8 3211static int smk_curacc_msq(struct kern_ipc_perm *isp, int access)
ecfcc53f 3212{
0d79cbf8 3213 struct smack_known *msp = smack_of_ipc(isp);
ecfcc53f 3214 struct smk_audit_info ad;
d166c802 3215 int rc;
ecfcc53f
EB		 3216
3217#ifdef CONFIG_AUDIT
3218 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
0d79cbf8 3219 ad.a.u.ipc_id = isp->id;
ecfcc53f 3220#endif
d166c802
CS		 3221 rc = smk_curacc(msp, access, &ad);
3222 rc = smk_bu_current("msq", msp, access, rc);
3223 return rc;
ecfcc53f
EB		 3224}
3225
e114e473
CS		 3226/**
3227 * smack_msg_queue_associate - Smack access check for msg_queue
0d79cbf8 3228 * @isp: the object
e114e473
CS		 3229 * @msqflg: access requested
3230 *
3231 * Returns 0 if current has the requested access, error code otherwise
3232 */
0d79cbf8 3233static int smack_msg_queue_associate(struct kern_ipc_perm *isp, int msqflg)
e114e473 3234{
e114e473
CS		 3235 int may;
3236
3237 may = smack_flags_to_may(msqflg);
0d79cbf8 3238 return smk_curacc_msq(isp, may);
e114e473
CS		 3239}
3240
3241/**
3242 * smack_msg_queue_msgctl - Smack access check for msg_queue
0d79cbf8 3243 * @isp: the object
e114e473
CS		 3244 * @cmd: what it wants to do
3245 *
3246 * Returns 0 if current has the requested access, error code otherwise
3247 */
0d79cbf8 3248static int smack_msg_queue_msgctl(struct kern_ipc_perm *isp, int cmd)
e114e473 3249{
e114e473
CS		 3250 int may;
3251
3252 switch (cmd) {
3253 case IPC_STAT:
3254 case MSG_STAT:
23c8cec8 3255 case MSG_STAT_ANY:
e114e473
CS		 3256 may = MAY_READ;
3257 break;
3258 case IPC_SET:
3259 case IPC_RMID:
3260 may = MAY_READWRITE;
3261 break;
3262 case IPC_INFO:
3263 case MSG_INFO:
3264 /*
3265 * System level information
3266 */
3267 return 0;
3268 default:
3269 return -EINVAL;
3270 }
3271
0d79cbf8 3272 return smk_curacc_msq(isp, may);
e114e473
CS		 3273}
3274
3275/**
3276 * smack_msg_queue_msgsnd - Smack access check for msg_queue
0d79cbf8 3277 * @isp: the object
e114e473
CS		 3278 * @msg: unused
3279 * @msqflg: access requested
3280 *
3281 * Returns 0 if current has the requested access, error code otherwise
3282 */
0d79cbf8 3283static int smack_msg_queue_msgsnd(struct kern_ipc_perm *isp, struct msg_msg *msg,
e114e473
CS		 3284 int msqflg)
3285{
ecfcc53f 3286 int may;
e114e473 3287
ecfcc53f 3288 may = smack_flags_to_may(msqflg);
0d79cbf8 3289 return smk_curacc_msq(isp, may);
e114e473
CS		 3290}
3291
3292/**
3293 * smack_msg_queue_msgsnd - Smack access check for msg_queue
0d79cbf8 3294 * @isp: the object
e114e473
CS		 3295 * @msg: unused
3296 * @target: unused
3297 * @type: unused
3298 * @mode: unused
3299 *
3300 * Returns 0 if current has read and write access, error code otherwise
3301 */
0d79cbf8 3302static int smack_msg_queue_msgrcv(struct kern_ipc_perm *isp, struct msg_msg *msg,
e114e473
CS		 3303 struct task_struct *target, long type, int mode)
3304{
0d79cbf8 3305 return smk_curacc_msq(isp, MAY_READWRITE);
e114e473
CS		 3306}
3307
3308/**
3309 * smack_ipc_permission - Smack access for ipc_permission()
3310 * @ipp: the object permissions
3311 * @flag: access requested
3312 *
3313 * Returns 0 if current has read and write access, error code otherwise
3314 */
3315static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
3316{
21c7eae2 3317 struct smack_known *iskp = ipp->security;
ecfcc53f
EB		 3318 int may = smack_flags_to_may(flag);
3319 struct smk_audit_info ad;
d166c802 3320 int rc;
e114e473 3321
ecfcc53f
EB		 3322#ifdef CONFIG_AUDIT
3323 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
3324 ad.a.u.ipc_id = ipp->id;
3325#endif
21c7eae2
LP		 3326 rc = smk_curacc(iskp, may, &ad);
3327 rc = smk_bu_current("svipc", iskp, may, rc);
d166c802 3328 return rc;
e114e473
CS		 3329}
3330
d20bdda6
AD		 3331/**
3332 * smack_ipc_getsecid - Extract smack security id
251a2a95 3333 * @ipp: the object permissions
d20bdda6
AD		 3334 * @secid: where result will be saved
3335 */
3336static void smack_ipc_getsecid(struct kern_ipc_perm *ipp, u32 *secid)
3337{
21c7eae2 3338 struct smack_known *iskp = ipp->security;
d20bdda6 3339
21c7eae2 3340 *secid = iskp->smk_secid;
d20bdda6
AD		 3341}
3342
e114e473
CS		 3343/**
3344 * smack_d_instantiate - Make sure the blob is correct on an inode
3e62cbb8 3345 * @opt_dentry: dentry where inode will be attached
e114e473
CS		 3346 * @inode: the object
3347 *
3348 * Set the inode's security blob if it hasn't been done already.
3349 */
3350static void smack_d_instantiate(struct dentry *opt_dentry, struct inode *inode)
3351{
3352 struct super_block *sbp;
3353 struct superblock_smack *sbsp;
3354 struct inode_smack *isp;
2f823ff8
CS		 3355 struct smack_known *skp;
3356 struct smack_known *ckp = smk_of_current();
21c7eae2 3357 struct smack_known *final;
5c6d1125
JS		 3358 char trattr[TRANS_TRUE_SIZE];
3359 int transflag = 0;
2267b13a 3360 int rc;
e114e473
CS		 3361 struct dentry *dp;
3362
3363 if (inode == NULL)
3364 return;
3365
3366 isp = inode->i_security;
3367
3368 mutex_lock(&isp->smk_lock);
3369 /*
3370 * If the inode is already instantiated
3371 * take the quick way out
3372 */
3373 if (isp->smk_flags & SMK_INODE_INSTANT)
3374 goto unlockandout;
3375
3376 sbp = inode->i_sb;
3377 sbsp = sbp->s_security;
3378 /*
3379 * We're going to use the superblock default label
3380 * if there's no label on the file.
3381 */
3382 final = sbsp->smk_default;
3383
e97dcb0e
CS		 3384 /*
3385 * If this is the root inode the superblock
3386 * may be in the process of initialization.
3387 * If that is the case use the root value out
3388 * of the superblock.
3389 */
3390 if (opt_dentry->d_parent == opt_dentry) {
1d8c2326
ŁS		 3391 switch (sbp->s_magic) {
3392 case CGROUP_SUPER_MAGIC:
58c442f3 3393 case CGROUP2_SUPER_MAGIC:
36ea735b
CS		 3394 /*
3395 * The cgroup filesystem is never mounted,
3396 * so there's no opportunity to set the mount
3397 * options.
3398 */
21c7eae2
LP		 3399 sbsp->smk_root = &smack_known_star;
3400 sbsp->smk_default = &smack_known_star;
1d8c2326
ŁS		 3401 isp->smk_inode = sbsp->smk_root;
3402 break;
3403 case TMPFS_MAGIC:
3404 /*
3405 * What about shmem/tmpfs anonymous files with dentry
3406 * obtained from d_alloc_pseudo()?
3407 */
3408 isp->smk_inode = smk_of_current();
3409 break;
8da4aba5
RK		 3410 case PIPEFS_MAGIC:
3411 isp->smk_inode = smk_of_current();
3412 break;
805b65a8
RK		 3413 case SOCKFS_MAGIC:
3414 /*
3415 * Socket access is controlled by the socket
3416 * structures associated with the task involved.
3417 */
3418 isp->smk_inode = &smack_known_star;
3419 break;
1d8c2326
ŁS		 3420 default:
3421 isp->smk_inode = sbsp->smk_root;
3422 break;
36ea735b 3423 }
e97dcb0e
CS		 3424 isp->smk_flags |= SMK_INODE_INSTANT;
3425 goto unlockandout;
3426 }
3427
e114e473
CS		 3428 /*
3429 * This is pretty hackish.
3430 * Casey says that we shouldn't have to do
3431 * file system specific code, but it does help
3432 * with keeping it simple.
3433 */
3434 switch (sbp->s_magic) {
3435 case SMACK_MAGIC:
36ea735b 3436 case CGROUP_SUPER_MAGIC:
58c442f3 3437 case CGROUP2_SUPER_MAGIC:
e114e473 3438 /*
25985edc 3439 * Casey says that it's a little embarrassing
e114e473
CS		 3440 * that the smack file system doesn't do
3441 * extended attributes.
36ea735b 3442 *
36ea735b 3443 * Cgroupfs is special
e114e473 3444 */
21c7eae2 3445 final = &smack_known_star;
e114e473
CS		 3446 break;
3447 case DEVPTS_SUPER_MAGIC:
3448 /*
3449 * devpts seems content with the label of the task.
3450 * Programs that change smack have to treat the
3451 * pty with respect.
3452 */
21c7eae2 3453 final = ckp;
e114e473 3454 break;
e114e473
CS		 3455 case PROC_SUPER_MAGIC:
3456 /*
3457 * Casey says procfs appears not to care.
3458 * The superblock default suffices.
3459 */
3460 break;
3461 case TMPFS_MAGIC:
3462 /*
3463 * Device labels should come from the filesystem,
3464 * but watch out, because they're volitile,
3465 * getting recreated on every reboot.
3466 */
21c7eae2 3467 final = &smack_known_star;
e114e473
CS		 3468 /*
3469 * No break.
3470 *
3471 * If a smack value has been set we want to use it,
3472 * but since tmpfs isn't giving us the opportunity
3473 * to set mount options simulate setting the
3474 * superblock default.
3475 */
3476 default:
3477 /*
3478 * This isn't an understood special case.
3479 * Get the value from the xattr.
b4e0d5f0
CS		 3480 */
3481
3482 /*
3483 * UNIX domain sockets use lower level socket data.
3484 */
3485 if (S_ISSOCK(inode->i_mode)) {
21c7eae2 3486 final = &smack_known_star;
b4e0d5f0
CS		 3487 break;
3488 }
3489 /*
e114e473
CS		 3490 * No xattr support means, alas, no SMACK label.
3491 * Use the aforeapplied default.
3492 * It would be curious if the label of the task
3493 * does not match that assigned.
3494 */
5d6c3191
AG		 3495 if (!(inode->i_opflags & IOP_XATTR))
3496 break;
e114e473
CS		 3497 /*
3498 * Get the dentry for xattr.
3499 */
3e62cbb8 3500 dp = dget(opt_dentry);
2f823ff8 3501 skp = smk_fetch(XATTR_NAME_SMACK, inode, dp);
e774ad68 3502 if (!IS_ERR_OR_NULL(skp))
21c7eae2 3503 final = skp;
2267b13a
CS		 3504
3505 /*
3506 * Transmuting directory
3507 */
3508 if (S_ISDIR(inode->i_mode)) {
3509 /*
3510 * If this is a new directory and the label was
3511 * transmuted when the inode was initialized
3512 * set the transmute attribute on the directory
3513 * and mark the inode.
3514 *
3515 * If there is a transmute attribute on the
3516 * directory mark the inode.
3517 */
3518 if (isp->smk_flags & SMK_INODE_CHANGED) {
3519 isp->smk_flags &= ~SMK_INODE_CHANGED;
5d6c3191 3520 rc = __vfs_setxattr(dp, inode,
5c6d1125 3521 XATTR_NAME_SMACKTRANSMUTE,
2267b13a
CS		 3522 TRANS_TRUE, TRANS_TRUE_SIZE,
3523 0);
3524 } else {
5d6c3191 3525 rc = __vfs_getxattr(dp, inode,
2267b13a
CS		 3526 XATTR_NAME_SMACKTRANSMUTE, trattr,
3527 TRANS_TRUE_SIZE);
3528 if (rc >= 0 && strncmp(trattr, TRANS_TRUE,
3529 TRANS_TRUE_SIZE) != 0)
3530 rc = -EINVAL;
5c6d1125 3531 }
2267b13a
CS		 3532 if (rc >= 0)
3533 transflag = SMK_INODE_TRANSMUTE;
5c6d1125 3534 }
809c02e0
SF		 3535 /*
3536 * Don't let the exec or mmap label be "*" or "@".
3537 */
3538 skp = smk_fetch(XATTR_NAME_SMACKEXEC, inode, dp);
3539 if (IS_ERR(skp) || skp == &smack_known_star ||
3540 skp == &smack_known_web)
3541 skp = NULL;
3542 isp->smk_task = skp;
e774ad68 3543
19760ad0 3544 skp = smk_fetch(XATTR_NAME_SMACKMMAP, inode, dp);
e774ad68
LP		 3545 if (IS_ERR(skp) || skp == &smack_known_star ||
3546 skp == &smack_known_web)
19760ad0
CS		 3547 skp = NULL;
3548 isp->smk_mmap = skp;
676dac4b 3549
e114e473
CS		 3550 dput(dp);
3551 break;
3552 }
3553
3554 if (final == NULL)
21c7eae2 3555 isp->smk_inode = ckp;
e114e473
CS		 3556 else
3557 isp->smk_inode = final;
3558
5c6d1125 3559 isp->smk_flags |= (SMK_INODE_INSTANT | transflag);
e114e473
CS		 3560
3561unlockandout:
3562 mutex_unlock(&isp->smk_lock);
3563 return;
3564}
3565
3566/**
3567 * smack_getprocattr - Smack process attribute access
3568 * @p: the object task
3569 * @name: the name of the attribute in /proc/.../attr
3570 * @value: where to put the result
3571 *
3572 * Places a copy of the task Smack into value
3573 *
3574 * Returns the length of the smack label or an error code
3575 */
3576static int smack_getprocattr(struct task_struct *p, char *name, char **value)
3577{
6d1cff2a 3578 struct smack_known *skp = smk_of_task_struct(p);
e114e473
CS		 3579 char *cp;
3580 int slen;
3581
3582 if (strcmp(name, "current") != 0)
3583 return -EINVAL;
3584
2f823ff8 3585 cp = kstrdup(skp->smk_known, GFP_KERNEL);
e114e473
CS		 3586 if (cp == NULL)
3587 return -ENOMEM;
3588
3589 slen = strlen(cp);
3590 *value = cp;
3591 return slen;
3592}
3593
3594/**
3595 * smack_setprocattr - Smack process attribute setting
e114e473
CS		 3596 * @name: the name of the attribute in /proc/.../attr
3597 * @value: the value to set
3598 * @size: the size of the value
3599 *
3600 * Sets the Smack value of the task. Only setting self
3601 * is permitted and only with privilege
3602 *
3603 * Returns the length of the smack label or an error code
3604 */
b21507e2 3605static int smack_setprocattr(const char *name, void *value, size_t size)
e114e473 3606{
38416e53 3607 struct task_smack *tsp = current_security();
d84f4f99 3608 struct cred *new;
2f823ff8 3609 struct smack_known *skp;
38416e53
ZJ		 3610 struct smack_known_list_elem *sklep;
3611 int rc;
e114e473 3612
38416e53 3613 if (!smack_privileged(CAP_MAC_ADMIN) && list_empty(&tsp->smk_relabel))
5cd9c58f
DH		 3614 return -EPERM;
3615
f7112e6c 3616 if (value == NULL || size == 0 || size >= SMK_LONGLABEL)
e114e473
CS		 3617 return -EINVAL;
3618
3619 if (strcmp(name, "current") != 0)
3620 return -EINVAL;
3621
2f823ff8 3622 skp = smk_import_entry(value, size);
e774ad68
LP		 3623 if (IS_ERR(skp))
3624 return PTR_ERR(skp);
e114e473 3625
6d3dc07c 3626 /*
7128ea15
HS		 3627 * No process is ever allowed the web ("@") label
3628 * and the star ("*") label.
6d3dc07c 3629 */
7128ea15
HS		 3630 if (skp == &smack_known_web || skp == &smack_known_star)
3631 return -EINVAL;
6d3dc07c 3632
38416e53
ZJ		 3633 if (!smack_privileged(CAP_MAC_ADMIN)) {
3634 rc = -EPERM;
3635 list_for_each_entry(sklep, &tsp->smk_relabel, list)
3636 if (sklep->smk_label == skp) {
3637 rc = 0;
3638 break;
3639 }
3640 if (rc)
3641 return rc;
3642 }
3643
d84f4f99 3644 new = prepare_creds();
6d3dc07c 3645 if (new == NULL)
d84f4f99 3646 return -ENOMEM;
7898e1f8 3647
46a2f3b9 3648 tsp = new->security;
2f823ff8 3649 tsp->smk_task = skp;
38416e53
ZJ		 3650 /*
3651 * process can change its label only once
3652 */
3653 smk_destroy_label_list(&tsp->smk_relabel);
7898e1f8 3654
d84f4f99 3655 commit_creds(new);
e114e473
CS		 3656 return size;
3657}
3658
3659/**
3660 * smack_unix_stream_connect - Smack access on UDS
3610cda5
DM		 3661 * @sock: one sock
3662 * @other: the other sock
e114e473
CS		 3663 * @newsk: unused
3664 *
3665 * Return 0 if a subject with the smack of sock could access
3666 * an object with the smack of other, otherwise an error code
3667 */
3610cda5
DM		 3668static int smack_unix_stream_connect(struct sock *sock,
3669 struct sock *other, struct sock *newsk)
e114e473 3670{
2f823ff8 3671 struct smack_known *skp;
54e70ec5 3672 struct smack_known *okp;
d2e7ad19
JM		 3673 struct socket_smack *ssp = sock->sk_security;
3674 struct socket_smack *osp = other->sk_security;
975d5e55 3675 struct socket_smack *nsp = newsk->sk_security;
ecfcc53f 3676 struct smk_audit_info ad;
b4e0d5f0 3677 int rc = 0;
923e9a13
KC		 3678#ifdef CONFIG_AUDIT
3679 struct lsm_network_audit net;
923e9a13 3680#endif
b4e0d5f0 3681
2f823ff8
CS		 3682 if (!smack_privileged(CAP_MAC_OVERRIDE)) {
3683 skp = ssp->smk_out;
96be7b54 3684 okp = osp->smk_in;
54e70ec5
CS		 3685#ifdef CONFIG_AUDIT
3686 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3687 smk_ad_setfield_u_net_sk(&ad, other);
3688#endif
21c7eae2
LP		 3689 rc = smk_access(skp, okp, MAY_WRITE, &ad);
3690 rc = smk_bu_note("UDS connect", skp, okp, MAY_WRITE, rc);
d166c802 3691 if (rc == 0) {
96be7b54
ZJ		 3692 okp = osp->smk_out;
3693 skp = ssp->smk_in;
138a868f 3694 rc = smk_access(okp, skp, MAY_WRITE, &ad);
21c7eae2 3695 rc = smk_bu_note("UDS connect", okp, skp,
d166c802
CS		 3696 MAY_WRITE, rc);
3697 }
2f823ff8 3698 }
b4e0d5f0 3699
975d5e55
CS		 3700 /*
3701 * Cross reference the peer labels for SO_PEERSEC.
3702 */
3703 if (rc == 0) {
54e70ec5
CS		 3704 nsp->smk_packet = ssp->smk_out;
3705 ssp->smk_packet = osp->smk_out;
975d5e55
CS		 3706 }
3707
b4e0d5f0 3708 return rc;
e114e473
CS		 3709}
3710
3711/**
3712 * smack_unix_may_send - Smack access on UDS
3713 * @sock: one socket
3714 * @other: the other socket
3715 *
3716 * Return 0 if a subject with the smack of sock could access
3717 * an object with the smack of other, otherwise an error code
3718 */
3719static int smack_unix_may_send(struct socket *sock, struct socket *other)
3720{
b4e0d5f0
CS		 3721 struct socket_smack *ssp = sock->sk->sk_security;
3722 struct socket_smack *osp = other->sk->sk_security;
ecfcc53f 3723 struct smk_audit_info ad;
d166c802 3724 int rc;
e114e473 3725
923e9a13
KC		 3726#ifdef CONFIG_AUDIT
3727 struct lsm_network_audit net;
3728
48c62af6 3729 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
ecfcc53f 3730 smk_ad_setfield_u_net_sk(&ad, other->sk);
923e9a13 3731#endif
b4e0d5f0 3732
2f823ff8
CS		 3733 if (smack_privileged(CAP_MAC_OVERRIDE))
3734 return 0;
b4e0d5f0 3735
21c7eae2
LP		 3736 rc = smk_access(ssp->smk_out, osp->smk_in, MAY_WRITE, &ad);
3737 rc = smk_bu_note("UDS send", ssp->smk_out, osp->smk_in, MAY_WRITE, rc);
d166c802 3738 return rc;
e114e473
CS		 3739}
3740
6d3dc07c
CS		 3741/**
3742 * smack_socket_sendmsg - Smack check based on destination host
3743 * @sock: the socket
251a2a95 3744 * @msg: the message
6d3dc07c
CS		 3745 * @size: the size of the message
3746 *
c6739443
CS		 3747 * Return 0 if the current subject can write to the destination host.
3748 * For IPv4 this is only a question if the destination is a single label host.
3749 * For IPv6 this is a check against the label of the port.
6d3dc07c
CS		 3750 */
3751static int smack_socket_sendmsg(struct socket *sock, struct msghdr *msg,
3752 int size)
3753{
3754 struct sockaddr_in *sip = (struct sockaddr_in *) msg->msg_name;
21abb1ec 3755#if IS_ENABLED(CONFIG_IPV6)
6ea06247 3756 struct sockaddr_in6 *sap = (struct sockaddr_in6 *) msg->msg_name;
21abb1ec
CS		 3757#endif
3758#ifdef SMACK_IPV6_SECMARK_LABELING
3759 struct socket_smack *ssp = sock->sk->sk_security;
3760 struct smack_known *rsp;
3761#endif
c6739443 3762 int rc = 0;
6d3dc07c
CS		 3763
3764 /*
3765 * Perfectly reasonable for this to be NULL
3766 */
c6739443 3767 if (sip == NULL)
6d3dc07c
CS		 3768 return 0;
3769
81bd0d56 3770 switch (sock->sk->sk_family) {
c6739443
CS		 3771 case AF_INET:
3772 rc = smack_netlabel_send(sock->sk, sip);
3773 break;
3774 case AF_INET6:
21abb1ec
CS		 3775#ifdef SMACK_IPV6_SECMARK_LABELING
3776 rsp = smack_ipv6host_label(sap);
3777 if (rsp != NULL)
3778 rc = smk_ipv6_check(ssp->smk_out, rsp, sap,
3779 SMK_CONNECTING);
3780#endif
3781#ifdef SMACK_IPV6_PORT_LABELING
c6739443 3782 rc = smk_ipv6_port_check(sock->sk, sap, SMK_SENDING);
21abb1ec 3783#endif
c6739443
CS		 3784 break;
3785 }
3786 return rc;
6d3dc07c
CS		 3787}
3788
e114e473 3789/**
251a2a95 3790 * smack_from_secattr - Convert a netlabel attr.mls.lvl/attr.mls.cat pair to smack
e114e473 3791 * @sap: netlabel secattr
272cd7a8 3792 * @ssp: socket security information
e114e473 3793 *
2f823ff8 3794 * Returns a pointer to a Smack label entry found on the label list.
e114e473 3795 */
2f823ff8
CS		 3796static struct smack_known *smack_from_secattr(struct netlbl_lsm_secattr *sap,
3797 struct socket_smack *ssp)
e114e473 3798{
2f823ff8 3799 struct smack_known *skp;
f7112e6c 3800 int found = 0;
677264e8
CS		 3801 int acat;
3802 int kcat;
e114e473 3803
6d3dc07c 3804 if ((sap->flags & NETLBL_SECATTR_MLS_LVL) != 0) {
e114e473 3805 /*
6d3dc07c 3806 * Looks like a CIPSO packet.
e114e473
CS		 3807 * If there are flags but no level netlabel isn't
3808 * behaving the way we expect it to.
3809 *
f7112e6c 3810 * Look it up in the label table
e114e473
CS		 3811 * Without guidance regarding the smack value
3812 * for the packet fall back on the network
3813 * ambient value.
3814 */
f7112e6c 3815 rcu_read_lock();
348dc288 3816 list_for_each_entry_rcu(skp, &smack_known_list, list) {
2f823ff8 3817 if (sap->attr.mls.lvl != skp->smk_netlabel.attr.mls.lvl)
f7112e6c 3818 continue;
677264e8
CS		 3819 /*
3820 * Compare the catsets. Use the netlbl APIs.
3821 */
3822 if ((sap->flags & NETLBL_SECATTR_MLS_CAT) == 0) {
3823 if ((skp->smk_netlabel.flags &
3824 NETLBL_SECATTR_MLS_CAT) == 0)
3825 found = 1;
3826 break;
3827 }
3828 for (acat = -1, kcat = -1; acat == kcat; ) {
4fbe63d1
PM		 3829 acat = netlbl_catmap_walk(sap->attr.mls.cat,
3830 acat + 1);
3831 kcat = netlbl_catmap_walk(
677264e8
CS		 3832 skp->smk_netlabel.attr.mls.cat,
3833 kcat + 1);
3834 if (acat < 0 || kcat < 0)
3835 break;
3836 }
3837 if (acat == kcat) {
3838 found = 1;
3839 break;
3840 }
6d3dc07c 3841 }
f7112e6c
CS		 3842 rcu_read_unlock();
3843
3844 if (found)
2f823ff8 3845 return skp;
f7112e6c 3846
54e70ec5 3847 if (ssp != NULL && ssp->smk_in == &smack_known_star)
2f823ff8
CS		 3848 return &smack_known_web;
3849 return &smack_known_star;
e114e473 3850 }
152f91d4 3851 if ((sap->flags & NETLBL_SECATTR_SECID) != 0)
6d3dc07c
CS		 3852 /*
3853 * Looks like a fallback, which gives us a secid.
3854 */
152f91d4 3855 return smack_from_secid(sap->attr.secid);
e114e473 3856 /*
6d3dc07c
CS		 3857 * Without guidance regarding the smack value
3858 * for the packet fall back on the network
3859 * ambient value.
e114e473 3860 */
272cd7a8 3861 return smack_net_ambient;
e114e473
CS		 3862}
3863
69f287ae 3864#if IS_ENABLED(CONFIG_IPV6)
6ea06247 3865static int smk_skb_to_addr_ipv6(struct sk_buff *skb, struct sockaddr_in6 *sip)
c6739443 3866{
c6739443
CS		 3867 u8 nexthdr;
3868 int offset;
3869 int proto = -EINVAL;
3870 struct ipv6hdr _ipv6h;
3871 struct ipv6hdr *ip6;
3872 __be16 frag_off;
3873 struct tcphdr _tcph, *th;
3874 struct udphdr _udph, *uh;
3875 struct dccp_hdr _dccph, *dh;
3876
3877 sip->sin6_port = 0;
3878
3879 offset = skb_network_offset(skb);
3880 ip6 = skb_header_pointer(skb, offset, sizeof(_ipv6h), &_ipv6h);
3881 if (ip6 == NULL)
3882 return -EINVAL;
3883 sip->sin6_addr = ip6->saddr;
3884
3885 nexthdr = ip6->nexthdr;
3886 offset += sizeof(_ipv6h);
3887 offset = ipv6_skip_exthdr(skb, offset, &nexthdr, &frag_off);
3888 if (offset < 0)
3889 return -EINVAL;
3890
3891 proto = nexthdr;
3892 switch (proto) {
3893 case IPPROTO_TCP:
3894 th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
3895 if (th != NULL)
3896 sip->sin6_port = th->source;
3897 break;
3898 case IPPROTO_UDP:
3899 uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
3900 if (uh != NULL)
3901 sip->sin6_port = uh->source;
3902 break;
3903 case IPPROTO_DCCP:
3904 dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
3905 if (dh != NULL)
3906 sip->sin6_port = dh->dccph_sport;
3907 break;
3908 }
3909 return proto;
3910}
69f287ae 3911#endif /* CONFIG_IPV6 */
c6739443 3912
e114e473
CS		 3913/**
3914 * smack_socket_sock_rcv_skb - Smack packet delivery access check
3915 * @sk: socket
3916 * @skb: packet
3917 *
3918 * Returns 0 if the packet should be delivered, an error code otherwise
3919 */
3920static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
3921{
3922 struct netlbl_lsm_secattr secattr;
3923 struct socket_smack *ssp = sk->sk_security;
69f287ae 3924 struct smack_known *skp = NULL;
c6739443 3925 int rc = 0;
ecfcc53f 3926 struct smk_audit_info ad;
923e9a13 3927#ifdef CONFIG_AUDIT
48c62af6 3928 struct lsm_network_audit net;
923e9a13 3929#endif
69f287ae
CS		 3930#if IS_ENABLED(CONFIG_IPV6)
3931 struct sockaddr_in6 sadd;
3932 int proto;
3933#endif /* CONFIG_IPV6 */
3934
c6739443
CS		 3935 switch (sk->sk_family) {
3936 case PF_INET:
69f287ae
CS		 3937#ifdef CONFIG_SECURITY_SMACK_NETFILTER
3938 /*
3939 * If there is a secmark use it rather than the CIPSO label.
3940 * If there is no secmark fall back to CIPSO.
3941 * The secmark is assumed to reflect policy better.
3942 */
3943 if (skb && skb->secmark != 0) {
3944 skp = smack_from_secid(skb->secmark);
3945 goto access_check;
3946 }
3947#endif /* CONFIG_SECURITY_SMACK_NETFILTER */
c6739443
CS		 3948 /*
3949 * Translate what netlabel gave us.
3950 */
3951 netlbl_secattr_init(&secattr);
6d3dc07c 3952
c6739443
CS		 3953 rc = netlbl_skbuff_getattr(skb, sk->sk_family, &secattr);
3954 if (rc == 0)
2f823ff8 3955 skp = smack_from_secattr(&secattr, ssp);
c6739443 3956 else
2f823ff8 3957 skp = smack_net_ambient;
6d3dc07c 3958
c6739443 3959 netlbl_secattr_destroy(&secattr);
6d3dc07c 3960
69f287ae
CS		 3961#ifdef CONFIG_SECURITY_SMACK_NETFILTER
3962access_check:
3963#endif
ecfcc53f 3964#ifdef CONFIG_AUDIT
c6739443
CS		 3965 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3966 ad.a.u.net->family = sk->sk_family;
3967 ad.a.u.net->netif = skb->skb_iif;
3968 ipv4_skb_to_auditdata(skb, &ad.a, NULL);
ecfcc53f 3969#endif
c6739443
CS		 3970 /*
3971 * Receiving a packet requires that the other end
3972 * be able to write here. Read access is not required.
3973 * This is the simplist possible security model
3974 * for networking.
3975 */
21c7eae2
LP		 3976 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
3977 rc = smk_bu_note("IPv4 delivery", skp, ssp->smk_in,
d166c802 3978 MAY_WRITE, rc);
c6739443 3979 if (rc != 0)
a04e71f6 3980 netlbl_skbuff_err(skb, sk->sk_family, rc, 0);
c6739443 3981 break;
69f287ae 3982#if IS_ENABLED(CONFIG_IPV6)
c6739443 3983 case PF_INET6:
69f287ae
CS		 3984 proto = smk_skb_to_addr_ipv6(skb, &sadd);
3985 if (proto != IPPROTO_UDP && proto != IPPROTO_TCP)
3986 break;
21abb1ec 3987#ifdef SMACK_IPV6_SECMARK_LABELING
69f287ae
CS		 3988 if (skb && skb->secmark != 0)
3989 skp = smack_from_secid(skb->secmark);
c6739443 3990 else
21abb1ec
CS		 3991 skp = smack_ipv6host_label(&sadd);
3992 if (skp == NULL)
69f287ae
CS		 3993 skp = smack_net_ambient;
3994#ifdef CONFIG_AUDIT
3995 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
3996 ad.a.u.net->family = sk->sk_family;
3997 ad.a.u.net->netif = skb->skb_iif;
3998 ipv6_skb_to_auditdata(skb, &ad.a, NULL);
3999#endif /* CONFIG_AUDIT */
4000 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
4001 rc = smk_bu_note("IPv6 delivery", skp, ssp->smk_in,
4002 MAY_WRITE, rc);
21abb1ec
CS		 4003#endif /* SMACK_IPV6_SECMARK_LABELING */
4004#ifdef SMACK_IPV6_PORT_LABELING
69f287ae 4005 rc = smk_ipv6_port_check(sk, &sadd, SMK_RECEIVING);
21abb1ec 4006#endif /* SMACK_IPV6_PORT_LABELING */
c6739443 4007 break;
69f287ae 4008#endif /* CONFIG_IPV6 */
c6739443 4009 }
69f287ae 4010
a8134296 4011 return rc;
e114e473
CS		 4012}
4013
4014/**
4015 * smack_socket_getpeersec_stream - pull in packet label
4016 * @sock: the socket
4017 * @optval: user's destination
4018 * @optlen: size thereof
251a2a95 4019 * @len: max thereof
e114e473
CS		 4020 *
4021 * returns zero on success, an error code otherwise
4022 */
4023static int smack_socket_getpeersec_stream(struct socket *sock,
4024 char __user *optval,
4025 int __user *optlen, unsigned len)
4026{
4027 struct socket_smack *ssp;
272cd7a8
CS		 4028 char *rcp = "";
4029 int slen = 1;
e114e473
CS		 4030 int rc = 0;
4031
4032 ssp = sock->sk->sk_security;
272cd7a8 4033 if (ssp->smk_packet != NULL) {
54e70ec5 4034 rcp = ssp->smk_packet->smk_known;
272cd7a8
CS		 4035 slen = strlen(rcp) + 1;
4036 }
e114e473
CS		 4037
4038 if (slen > len)
4039 rc = -ERANGE;
272cd7a8 4040 else if (copy_to_user(optval, rcp, slen) != 0)
e114e473
CS		 4041 rc = -EFAULT;
4042
4043 if (put_user(slen, optlen) != 0)
4044 rc = -EFAULT;
4045
4046 return rc;
4047}
4048
4049
4050/**
4051 * smack_socket_getpeersec_dgram - pull in packet label
b4e0d5f0 4052 * @sock: the peer socket
e114e473
CS		 4053 * @skb: packet data
4054 * @secid: pointer to where to put the secid of the packet
4055 *
4056 * Sets the netlabel socket state on sk from parent
4057 */
4058static int smack_socket_getpeersec_dgram(struct socket *sock,
4059 struct sk_buff *skb, u32 *secid)
4060
4061{
4062 struct netlbl_lsm_secattr secattr;
272cd7a8 4063 struct socket_smack *ssp = NULL;
2f823ff8 4064 struct smack_known *skp;
b4e0d5f0
CS		 4065 int family = PF_UNSPEC;
4066 u32 s = 0; /* 0 is the invalid secid */
e114e473
CS		 4067 int rc;
4068
b4e0d5f0
CS		 4069 if (skb != NULL) {
4070 if (skb->protocol == htons(ETH_P_IP))
4071 family = PF_INET;
69f287ae 4072#if IS_ENABLED(CONFIG_IPV6)
b4e0d5f0
CS		 4073 else if (skb->protocol == htons(ETH_P_IPV6))
4074 family = PF_INET6;
69f287ae 4075#endif /* CONFIG_IPV6 */
e114e473 4076 }
b4e0d5f0
CS		 4077 if (family == PF_UNSPEC && sock != NULL)
4078 family = sock->sk->sk_family;
e114e473 4079
69f287ae
CS		 4080 switch (family) {
4081 case PF_UNIX:
272cd7a8 4082 ssp = sock->sk->sk_security;
2f823ff8 4083 s = ssp->smk_out->smk_secid;
69f287ae
CS		 4084 break;
4085 case PF_INET:
4086#ifdef CONFIG_SECURITY_SMACK_NETFILTER
4087 s = skb->secmark;
4088 if (s != 0)
4089 break;
4090#endif
b4e0d5f0
CS		 4091 /*
4092 * Translate what netlabel gave us.
4093 */
272cd7a8
CS		 4094 if (sock != NULL && sock->sk != NULL)
4095 ssp = sock->sk->sk_security;
b4e0d5f0
CS		 4096 netlbl_secattr_init(&secattr);
4097 rc = netlbl_skbuff_getattr(skb, family, &secattr);
4098 if (rc == 0) {
2f823ff8
CS		 4099 skp = smack_from_secattr(&secattr, ssp);
4100 s = skp->smk_secid;
b4e0d5f0
CS		 4101 }
4102 netlbl_secattr_destroy(&secattr);
69f287ae 4103 break;
69f287ae 4104 case PF_INET6:
21abb1ec 4105#ifdef SMACK_IPV6_SECMARK_LABELING
69f287ae 4106 s = skb->secmark;
21abb1ec 4107#endif
69f287ae 4108 break;
b4e0d5f0
CS		 4109 }
4110 *secid = s;
e114e473
CS		 4111 if (s == 0)
4112 return -EINVAL;
e114e473
CS		 4113 return 0;
4114}
4115
4116/**
07feee8f
PM		 4117 * smack_sock_graft - Initialize a newly created socket with an existing sock
4118 * @sk: child sock
4119 * @parent: parent socket
e114e473 4120 *
07feee8f
PM		 4121 * Set the smk_{in,out} state of an existing sock based on the process that
4122 * is creating the new socket.
e114e473
CS		 4123 */
4124static void smack_sock_graft(struct sock *sk, struct socket *parent)
4125{
4126 struct socket_smack *ssp;
2f823ff8 4127 struct smack_known *skp = smk_of_current();
e114e473 4128
07feee8f
PM		 4129 if (sk == NULL ||
4130 (sk->sk_family != PF_INET && sk->sk_family != PF_INET6))
e114e473
CS		 4131 return;
4132
4133 ssp = sk->sk_security;
54e70ec5 4134 ssp->smk_in = skp;
2f823ff8 4135 ssp->smk_out = skp;
07feee8f 4136 /* cssp->smk_packet is already set in smack_inet_csk_clone() */
e114e473
CS		 4137}
4138
4139/**
4140 * smack_inet_conn_request - Smack access check on connect
4141 * @sk: socket involved
4142 * @skb: packet
4143 * @req: unused
4144 *
4145 * Returns 0 if a task with the packet label could write to
4146 * the socket, otherwise an error code
4147 */
4148static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
4149 struct request_sock *req)
4150{
07feee8f 4151 u16 family = sk->sk_family;
f7112e6c 4152 struct smack_known *skp;
e114e473 4153 struct socket_smack *ssp = sk->sk_security;
07feee8f
PM		 4154 struct netlbl_lsm_secattr secattr;
4155 struct sockaddr_in addr;
4156 struct iphdr *hdr;
21c7eae2 4157 struct smack_known *hskp;
e114e473 4158 int rc;
ecfcc53f 4159 struct smk_audit_info ad;
923e9a13 4160#ifdef CONFIG_AUDIT
48c62af6 4161 struct lsm_network_audit net;
923e9a13 4162#endif
e114e473 4163
69f287ae 4164#if IS_ENABLED(CONFIG_IPV6)
c6739443
CS		 4165 if (family == PF_INET6) {
4166 /*
4167 * Handle mapped IPv4 packets arriving
4168 * via IPv6 sockets. Don't set up netlabel
4169 * processing on IPv6.
4170 */
4171 if (skb->protocol == htons(ETH_P_IP))
4172 family = PF_INET;
4173 else
4174 return 0;
4175 }
69f287ae 4176#endif /* CONFIG_IPV6 */
e114e473 4177
7f368ad3
CS		 4178#ifdef CONFIG_SECURITY_SMACK_NETFILTER
4179 /*
4180 * If there is a secmark use it rather than the CIPSO label.
4181 * If there is no secmark fall back to CIPSO.
4182 * The secmark is assumed to reflect policy better.
4183 */
4184 if (skb && skb->secmark != 0) {
4185 skp = smack_from_secid(skb->secmark);
4186 goto access_check;
4187 }
4188#endif /* CONFIG_SECURITY_SMACK_NETFILTER */
4189
07feee8f
PM		 4190 netlbl_secattr_init(&secattr);
4191 rc = netlbl_skbuff_getattr(skb, family, &secattr);
e114e473 4192 if (rc == 0)
2f823ff8 4193 skp = smack_from_secattr(&secattr, ssp);
e114e473 4194 else
2f823ff8 4195 skp = &smack_known_huh;
07feee8f
PM		 4196 netlbl_secattr_destroy(&secattr);
4197
7f368ad3
CS		 4198#ifdef CONFIG_SECURITY_SMACK_NETFILTER
4199access_check:
4200#endif
4201
ecfcc53f 4202#ifdef CONFIG_AUDIT
48c62af6
EP		 4203 smk_ad_init_net(&ad, __func__, LSM_AUDIT_DATA_NET, &net);
4204 ad.a.u.net->family = family;
4205 ad.a.u.net->netif = skb->skb_iif;
ecfcc53f
EB		 4206 ipv4_skb_to_auditdata(skb, &ad.a, NULL);
4207#endif
e114e473 4208 /*
07feee8f
PM		 4209 * Receiving a packet requires that the other end be able to write
4210 * here. Read access is not required.
e114e473 4211 */
21c7eae2
LP		 4212 rc = smk_access(skp, ssp->smk_in, MAY_WRITE, &ad);
4213 rc = smk_bu_note("IPv4 connect", skp, ssp->smk_in, MAY_WRITE, rc);
07feee8f
PM		 4214 if (rc != 0)
4215 return rc;
4216
4217 /*
4218 * Save the peer's label in the request_sock so we can later setup
4219 * smk_packet in the child socket so that SO_PEERCRED can report it.
4220 */
2f823ff8 4221 req->peer_secid = skp->smk_secid;
07feee8f
PM		 4222
4223 /*
4224 * We need to decide if we want to label the incoming connection here
4225 * if we do we only need to label the request_sock and the stack will
25985edc 4226 * propagate the wire-label to the sock when it is created.
07feee8f
PM		 4227 */
4228 hdr = ip_hdr(skb);
4229 addr.sin_addr.s_addr = hdr->saddr;
4230 rcu_read_lock();
21abb1ec 4231 hskp = smack_ipv4host_label(&addr);
f7112e6c
CS		 4232 rcu_read_unlock();
4233
21c7eae2 4234 if (hskp == NULL)
f7112e6c 4235 rc = netlbl_req_setattr(req, &skp->smk_netlabel);
2f823ff8 4236 else
07feee8f 4237 netlbl_req_delattr(req);
e114e473
CS		 4238
4239 return rc;
4240}
4241
07feee8f
PM		 4242/**
4243 * smack_inet_csk_clone - Copy the connection information to the new socket
4244 * @sk: the new socket
4245 * @req: the connection's request_sock
4246 *
4247 * Transfer the connection's peer label to the newly created socket.
4248 */
4249static void smack_inet_csk_clone(struct sock *sk,
4250 const struct request_sock *req)
4251{
4252 struct socket_smack *ssp = sk->sk_security;
2f823ff8 4253 struct smack_known *skp;
07feee8f 4254
2f823ff8
CS		 4255 if (req->peer_secid != 0) {
4256 skp = smack_from_secid(req->peer_secid);
54e70ec5 4257 ssp->smk_packet = skp;
2f823ff8 4258 } else
272cd7a8 4259 ssp->smk_packet = NULL;
07feee8f
PM		 4260}
4261
e114e473
CS		 4262/*
4263 * Key management security hooks
4264 *
4265 * Casey has not tested key support very heavily.
4266 * The permission check is most likely too restrictive.
4267 * If you care about keys please have a look.
4268 */
4269#ifdef CONFIG_KEYS
4270
4271/**
4272 * smack_key_alloc - Set the key security blob
4273 * @key: object
d84f4f99 4274 * @cred: the credentials to use
e114e473
CS		 4275 * @flags: unused
4276 *
4277 * No allocation required
4278 *
4279 * Returns 0
4280 */
d84f4f99 4281static int smack_key_alloc(struct key *key, const struct cred *cred,
e114e473
CS		 4282 unsigned long flags)
4283{
2f823ff8
CS		 4284 struct smack_known *skp = smk_of_task(cred->security);
4285
21c7eae2 4286 key->security = skp;
e114e473
CS		 4287 return 0;
4288}
4289
4290/**
4291 * smack_key_free - Clear the key security blob
4292 * @key: the object
4293 *
4294 * Clear the blob pointer
4295 */
4296static void smack_key_free(struct key *key)
4297{
4298 key->security = NULL;
4299}
4300
1a28979b 4301/**
e114e473
CS		 4302 * smack_key_permission - Smack access on a key
4303 * @key_ref: gets to the object
d84f4f99 4304 * @cred: the credentials to use
1a28979b 4305 * @perm: requested key permissions
e114e473
CS		 4306 *
4307 * Return 0 if the task has read and write to the object,
4308 * an error code otherwise
4309 */
4310static int smack_key_permission(key_ref_t key_ref,
f5895943 4311 const struct cred *cred, unsigned perm)
e114e473
CS		 4312{
4313 struct key *keyp;
ecfcc53f 4314 struct smk_audit_info ad;
2f823ff8 4315 struct smack_known *tkp = smk_of_task(cred->security);
fffea214 4316 int request = 0;
d166c802 4317 int rc;
e114e473
CS		 4318
4319 keyp = key_ref_to_ptr(key_ref);
4320 if (keyp == NULL)
4321 return -EINVAL;
4322 /*
4323 * If the key hasn't been initialized give it access so that
4324 * it may do so.
4325 */
4326 if (keyp->security == NULL)
4327 return 0;
4328 /*
4329 * This should not occur
4330 */
2f823ff8 4331 if (tkp == NULL)
e114e473 4332 return -EACCES;
d19dfe58
CS		 4333
4334 if (smack_privileged_cred(CAP_MAC_OVERRIDE, cred))
4335 return 0;
4336
ecfcc53f
EB		 4337#ifdef CONFIG_AUDIT
4338 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY);
4339 ad.a.u.key_struct.key = keyp->serial;
4340 ad.a.u.key_struct.key_desc = keyp->description;
4341#endif
fffea214
DK		 4342 if (perm & KEY_NEED_READ)
4343 request = MAY_READ;
4344 if (perm & (KEY_NEED_WRITE | KEY_NEED_LINK | KEY_NEED_SETATTR))
4345 request = MAY_WRITE;
d166c802
CS		 4346 rc = smk_access(tkp, keyp->security, request, &ad);
4347 rc = smk_bu_note("key access", tkp, keyp->security, request, rc);
4348 return rc;
e114e473 4349}
7fc5f36e
JB		 4350
4351/*
4352 * smack_key_getsecurity - Smack label tagging the key
4353 * @key points to the key to be queried
4354 * @_buffer points to a pointer that should be set to point to the
4355 * resulting string (if no label or an error occurs).
4356 * Return the length of the string (including terminating NUL) or -ve if
4357 * an error.
4358 * May also return 0 (and a NULL buffer pointer) if there is no label.
4359 */
4360static int smack_key_getsecurity(struct key *key, char **_buffer)
4361{
4362 struct smack_known *skp = key->security;
4363 size_t length;
4364 char *copy;
4365
4366 if (key->security == NULL) {
4367 *_buffer = NULL;
4368 return 0;
4369 }
4370
4371 copy = kstrdup(skp->smk_known, GFP_KERNEL);
4372 if (copy == NULL)
4373 return -ENOMEM;
4374 length = strlen(copy) + 1;
4375
4376 *_buffer = copy;
4377 return length;
4378}
4379
e114e473
CS		 4380#endif /* CONFIG_KEYS */
4381
d20bdda6
AD		 4382/*
4383 * Smack Audit hooks
4384 *
4385 * Audit requires a unique representation of each Smack specific
4386 * rule. This unique representation is used to distinguish the
4387 * object to be audited from remaining kernel objects and also
4388 * works as a glue between the audit hooks.
4389 *
4390 * Since repository entries are added but never deleted, we'll use
4391 * the smack_known label address related to the given audit rule as
4392 * the needed unique representation. This also better fits the smack
4393 * model where nearly everything is a label.
4394 */
4395#ifdef CONFIG_AUDIT
4396
4397/**
4398 * smack_audit_rule_init - Initialize a smack audit rule
4399 * @field: audit rule fields given from user-space (audit.h)
4400 * @op: required testing operator (=, !=, >, <, ...)
4401 * @rulestr: smack label to be audited
4402 * @vrule: pointer to save our own audit rule representation
4403 *
4404 * Prepare to audit cases where (@field @op @rulestr) is true.
4405 * The label to be audited is created if necessay.
4406 */
4407static int smack_audit_rule_init(u32 field, u32 op, char *rulestr, void **vrule)
4408{
21c7eae2 4409 struct smack_known *skp;
d20bdda6
AD		 4410 char **rule = (char **)vrule;
4411 *rule = NULL;
4412
4413 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
4414 return -EINVAL;
4415
5af75d8d 4416 if (op != Audit_equal && op != Audit_not_equal)
d20bdda6
AD		 4417 return -EINVAL;
4418
21c7eae2 4419 skp = smk_import_entry(rulestr, 0);
e774ad68
LP		 4420 if (IS_ERR(skp))
4421 return PTR_ERR(skp);
4422
4423 *rule = skp->smk_known;
d20bdda6
AD		 4424
4425 return 0;
4426}
4427
4428/**
4429 * smack_audit_rule_known - Distinguish Smack audit rules
4430 * @krule: rule of interest, in Audit kernel representation format
4431 *
4432 * This is used to filter Smack rules from remaining Audit ones.
4433 * If it's proved that this rule belongs to us, the
4434 * audit_rule_match hook will be called to do the final judgement.
4435 */
4436static int smack_audit_rule_known(struct audit_krule *krule)
4437{
4438 struct audit_field *f;
4439 int i;
4440
4441 for (i = 0; i < krule->field_count; i++) {
4442 f = &krule->fields[i];
4443
4444 if (f->type == AUDIT_SUBJ_USER || f->type == AUDIT_OBJ_USER)
4445 return 1;
4446 }
4447
4448 return 0;
4449}
4450
4451/**
4452 * smack_audit_rule_match - Audit given object ?
4453 * @secid: security id for identifying the object to test
4454 * @field: audit rule flags given from user-space
4455 * @op: required testing operator
4456 * @vrule: smack internal rule presentation
4457 * @actx: audit context associated with the check
4458 *
4459 * The core Audit hook. It's used to take the decision of
4460 * whether to audit or not to audit a given object.
4461 */
4462static int smack_audit_rule_match(u32 secid, u32 field, u32 op, void *vrule,
4463 struct audit_context *actx)
4464{
2f823ff8 4465 struct smack_known *skp;
d20bdda6
AD		 4466 char *rule = vrule;
4467
4eb0f4ab
RGB		 4468 if (unlikely(!rule)) {
4469 WARN_ONCE(1, "Smack: missing rule\n");
d20bdda6
AD		 4470 return -ENOENT;
4471 }
4472
4473 if (field != AUDIT_SUBJ_USER && field != AUDIT_OBJ_USER)
4474 return 0;
4475
2f823ff8 4476 skp = smack_from_secid(secid);
d20bdda6
AD		 4477
4478 /*
4479 * No need to do string comparisons. If a match occurs,
4480 * both pointers will point to the same smack_known
4481 * label.
4482 */
5af75d8d 4483 if (op == Audit_equal)
2f823ff8 4484 return (rule == skp->smk_known);
5af75d8d 4485 if (op == Audit_not_equal)
2f823ff8 4486 return (rule != skp->smk_known);
d20bdda6
AD		 4487
4488 return 0;
4489}
4490
491a0b08
CS		 4491/*
4492 * There is no need for a smack_audit_rule_free hook.
d20bdda6
AD		 4493 * No memory was allocated.
4494 */
d20bdda6
AD		 4495
4496#endif /* CONFIG_AUDIT */
4497
746df9b5
DQ		 4498/**
4499 * smack_ismaclabel - check if xattr @name references a smack MAC label
4500 * @name: Full xattr name to check.
4501 */
4502static int smack_ismaclabel(const char *name)
4503{
4504 return (strcmp(name, XATTR_SMACK_SUFFIX) == 0);
4505}
4506
4507
251a2a95 4508/**
e114e473
CS		 4509 * smack_secid_to_secctx - return the smack label for a secid
4510 * @secid: incoming integer
4511 * @secdata: destination
4512 * @seclen: how long it is
4513 *
4514 * Exists for networking code.
4515 */
4516static int smack_secid_to_secctx(u32 secid, char **secdata, u32 *seclen)
4517{
2f823ff8 4518 struct smack_known *skp = smack_from_secid(secid);
e114e473 4519
d5630b9d 4520 if (secdata)
2f823ff8
CS		 4521 *secdata = skp->smk_known;
4522 *seclen = strlen(skp->smk_known);
e114e473
CS		 4523 return 0;
4524}
4525
251a2a95 4526/**
4bc87e62
CS		 4527 * smack_secctx_to_secid - return the secid for a smack label
4528 * @secdata: smack label
4529 * @seclen: how long result is
4530 * @secid: outgoing integer
4531 *
4532 * Exists for audit and networking code.
4533 */
e52c1764 4534static int smack_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid)
4bc87e62 4535{
21c7eae2
LP		 4536 struct smack_known *skp = smk_find_entry(secdata);
4537
4538 if (skp)
4539 *secid = skp->smk_secid;
4540 else
4541 *secid = 0;
4bc87e62
CS		 4542 return 0;
4543}
4544
491a0b08
CS		 4545/*
4546 * There used to be a smack_release_secctx hook
4547 * that did nothing back when hooks were in a vector.
4548 * Now that there's a list such a hook adds cost.
e114e473 4549 */
e114e473 4550
1ee65e37
DQ		 4551static int smack_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen)
4552{
4553 return smack_inode_setsecurity(inode, XATTR_SMACK_SUFFIX, ctx, ctxlen, 0);
4554}
4555
4556static int smack_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen)
4557{
4558 return __vfs_setxattr_noperm(dentry, XATTR_NAME_SMACK, ctx, ctxlen, 0);
4559}
4560
4561static int smack_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen)
4562{
0f8983cf 4563 struct smack_known *skp = smk_of_inode(inode);
1ee65e37 4564
0f8983cf
CS		 4565 *ctx = skp->smk_known;
4566 *ctxlen = strlen(skp->smk_known);
1ee65e37
DQ		 4567 return 0;
4568}
4569
d6d80cb5
CS		 4570static int smack_inode_copy_up(struct dentry *dentry, struct cred **new)
4571{
4572
4573 struct task_smack *tsp;
4574 struct smack_known *skp;
4575 struct inode_smack *isp;
4576 struct cred *new_creds = *new;
4577
4578 if (new_creds == NULL) {
4579 new_creds = prepare_creds();
4580 if (new_creds == NULL)
4581 return -ENOMEM;
4582 }
4583
4584 tsp = new_creds->security;
4585
4586 /*
4587 * Get label from overlay inode and set it in create_sid
4588 */
4589 isp = d_inode(dentry->d_parent)->i_security;
4590 skp = isp->smk_inode;
4591 tsp->smk_task = skp;
4592 *new = new_creds;
4593 return 0;
4594}
4595
4596static int smack_inode_copy_up_xattr(const char *name)
4597{
4598 /*
4599 * Return 1 if this is the smack access Smack attribute.
4600 */
4601 if (strcmp(name, XATTR_NAME_SMACK) == 0)
4602 return 1;
4603
4604 return -EOPNOTSUPP;
4605}
4606
4607static int smack_dentry_create_files_as(struct dentry *dentry, int mode,
4608 struct qstr *name,
4609 const struct cred *old,
4610 struct cred *new)
4611{
4612 struct task_smack *otsp = old->security;
4613 struct task_smack *ntsp = new->security;
4614 struct inode_smack *isp;
4615 int may;
4616
4617 /*
4618 * Use the process credential unless all of
4619 * the transmuting criteria are met
4620 */
4621 ntsp->smk_task = otsp->smk_task;
4622
4623 /*
4624 * the attribute of the containing directory
4625 */
4626 isp = d_inode(dentry->d_parent)->i_security;
4627
4628 if (isp->smk_flags & SMK_INODE_TRANSMUTE) {
4629 rcu_read_lock();
4630 may = smk_access_entry(otsp->smk_task->smk_known,
4631 isp->smk_inode->smk_known,
4632 &otsp->smk_task->smk_rules);
4633 rcu_read_unlock();
4634
4635 /*
4636 * If the directory is transmuting and the rule
4637 * providing access is transmuting use the containing
4638 * directory label instead of the process label.
4639 */
4640 if (may > 0 && (may & MAY_TRANSMUTE))
4641 ntsp->smk_task = isp->smk_inode;
4642 }
4643 return 0;
4644}
4645
ca97d939 4646static struct security_hook_list smack_hooks[] __lsm_ro_after_init = {
e20b043a
CS		 4647 LSM_HOOK_INIT(ptrace_access_check, smack_ptrace_access_check),
4648 LSM_HOOK_INIT(ptrace_traceme, smack_ptrace_traceme),
4649 LSM_HOOK_INIT(syslog, smack_syslog),
4650
4651 LSM_HOOK_INIT(sb_alloc_security, smack_sb_alloc_security),
4652 LSM_HOOK_INIT(sb_free_security, smack_sb_free_security),
4653 LSM_HOOK_INIT(sb_copy_data, smack_sb_copy_data),
4654 LSM_HOOK_INIT(sb_kern_mount, smack_sb_kern_mount),
4655 LSM_HOOK_INIT(sb_statfs, smack_sb_statfs),
3bf2789c
VT		 4656 LSM_HOOK_INIT(sb_set_mnt_opts, smack_set_mnt_opts),
4657 LSM_HOOK_INIT(sb_parse_opts_str, smack_parse_opts_str),
e20b043a
CS		 4658
4659 LSM_HOOK_INIT(bprm_set_creds, smack_bprm_set_creds),
e20b043a
CS		 4660
4661 LSM_HOOK_INIT(inode_alloc_security, smack_inode_alloc_security),
4662 LSM_HOOK_INIT(inode_free_security, smack_inode_free_security),
4663 LSM_HOOK_INIT(inode_init_security, smack_inode_init_security),
4664 LSM_HOOK_INIT(inode_link, smack_inode_link),
4665 LSM_HOOK_INIT(inode_unlink, smack_inode_unlink),
4666 LSM_HOOK_INIT(inode_rmdir, smack_inode_rmdir),
4667 LSM_HOOK_INIT(inode_rename, smack_inode_rename),
4668 LSM_HOOK_INIT(inode_permission, smack_inode_permission),
4669 LSM_HOOK_INIT(inode_setattr, smack_inode_setattr),
4670 LSM_HOOK_INIT(inode_getattr, smack_inode_getattr),
4671 LSM_HOOK_INIT(inode_setxattr, smack_inode_setxattr),
4672 LSM_HOOK_INIT(inode_post_setxattr, smack_inode_post_setxattr),
4673 LSM_HOOK_INIT(inode_getxattr, smack_inode_getxattr),
4674 LSM_HOOK_INIT(inode_removexattr, smack_inode_removexattr),
4675 LSM_HOOK_INIT(inode_getsecurity, smack_inode_getsecurity),
4676 LSM_HOOK_INIT(inode_setsecurity, smack_inode_setsecurity),
4677 LSM_HOOK_INIT(inode_listsecurity, smack_inode_listsecurity),
4678 LSM_HOOK_INIT(inode_getsecid, smack_inode_getsecid),
4679
e20b043a
CS		 4680 LSM_HOOK_INIT(file_alloc_security, smack_file_alloc_security),
4681 LSM_HOOK_INIT(file_free_security, smack_file_free_security),
4682 LSM_HOOK_INIT(file_ioctl, smack_file_ioctl),
4683 LSM_HOOK_INIT(file_lock, smack_file_lock),
4684 LSM_HOOK_INIT(file_fcntl, smack_file_fcntl),
4685 LSM_HOOK_INIT(mmap_file, smack_mmap_file),
4686 LSM_HOOK_INIT(mmap_addr, cap_mmap_addr),
4687 LSM_HOOK_INIT(file_set_fowner, smack_file_set_fowner),
4688 LSM_HOOK_INIT(file_send_sigiotask, smack_file_send_sigiotask),
4689 LSM_HOOK_INIT(file_receive, smack_file_receive),
4690
4691 LSM_HOOK_INIT(file_open, smack_file_open),
4692
4693 LSM_HOOK_INIT(cred_alloc_blank, smack_cred_alloc_blank),
4694 LSM_HOOK_INIT(cred_free, smack_cred_free),
4695 LSM_HOOK_INIT(cred_prepare, smack_cred_prepare),
4696 LSM_HOOK_INIT(cred_transfer, smack_cred_transfer),
3ec30113 4697 LSM_HOOK_INIT(cred_getsecid, smack_cred_getsecid),
e20b043a
CS		 4698 LSM_HOOK_INIT(kernel_act_as, smack_kernel_act_as),
4699 LSM_HOOK_INIT(kernel_create_files_as, smack_kernel_create_files_as),
4700 LSM_HOOK_INIT(task_setpgid, smack_task_setpgid),
4701 LSM_HOOK_INIT(task_getpgid, smack_task_getpgid),
4702 LSM_HOOK_INIT(task_getsid, smack_task_getsid),
4703 LSM_HOOK_INIT(task_getsecid, smack_task_getsecid),
4704 LSM_HOOK_INIT(task_setnice, smack_task_setnice),
4705 LSM_HOOK_INIT(task_setioprio, smack_task_setioprio),
4706 LSM_HOOK_INIT(task_getioprio, smack_task_getioprio),
4707 LSM_HOOK_INIT(task_setscheduler, smack_task_setscheduler),
4708 LSM_HOOK_INIT(task_getscheduler, smack_task_getscheduler),
4709 LSM_HOOK_INIT(task_movememory, smack_task_movememory),
4710 LSM_HOOK_INIT(task_kill, smack_task_kill),
e20b043a
CS		 4711 LSM_HOOK_INIT(task_to_inode, smack_task_to_inode),
4712
4713 LSM_HOOK_INIT(ipc_permission, smack_ipc_permission),
4714 LSM_HOOK_INIT(ipc_getsecid, smack_ipc_getsecid),
4715
4716 LSM_HOOK_INIT(msg_msg_alloc_security, smack_msg_msg_alloc_security),
4717 LSM_HOOK_INIT(msg_msg_free_security, smack_msg_msg_free_security),
4718
0d79cbf8
EB		 4719 LSM_HOOK_INIT(msg_queue_alloc_security, smack_ipc_alloc_security),
4720 LSM_HOOK_INIT(msg_queue_free_security, smack_ipc_free_security),
e20b043a
CS		 4721 LSM_HOOK_INIT(msg_queue_associate, smack_msg_queue_associate),
4722 LSM_HOOK_INIT(msg_queue_msgctl, smack_msg_queue_msgctl),
4723 LSM_HOOK_INIT(msg_queue_msgsnd, smack_msg_queue_msgsnd),
4724 LSM_HOOK_INIT(msg_queue_msgrcv, smack_msg_queue_msgrcv),
4725
0d79cbf8
EB		 4726 LSM_HOOK_INIT(shm_alloc_security, smack_ipc_alloc_security),
4727 LSM_HOOK_INIT(shm_free_security, smack_ipc_free_security),
e20b043a
CS		 4728 LSM_HOOK_INIT(shm_associate, smack_shm_associate),
4729 LSM_HOOK_INIT(shm_shmctl, smack_shm_shmctl),
4730 LSM_HOOK_INIT(shm_shmat, smack_shm_shmat),
4731
0d79cbf8
EB		 4732 LSM_HOOK_INIT(sem_alloc_security, smack_ipc_alloc_security),
4733 LSM_HOOK_INIT(sem_free_security, smack_ipc_free_security),
e20b043a
CS		 4734 LSM_HOOK_INIT(sem_associate, smack_sem_associate),
4735 LSM_HOOK_INIT(sem_semctl, smack_sem_semctl),
4736 LSM_HOOK_INIT(sem_semop, smack_sem_semop),
4737
4738 LSM_HOOK_INIT(d_instantiate, smack_d_instantiate),
4739
4740 LSM_HOOK_INIT(getprocattr, smack_getprocattr),
4741 LSM_HOOK_INIT(setprocattr, smack_setprocattr),
4742
4743 LSM_HOOK_INIT(unix_stream_connect, smack_unix_stream_connect),
4744 LSM_HOOK_INIT(unix_may_send, smack_unix_may_send),
4745
4746 LSM_HOOK_INIT(socket_post_create, smack_socket_post_create),
5859cdf5 4747 LSM_HOOK_INIT(socket_socketpair, smack_socket_socketpair),
21abb1ec 4748#ifdef SMACK_IPV6_PORT_LABELING
e20b043a 4749 LSM_HOOK_INIT(socket_bind, smack_socket_bind),
21abb1ec 4750#endif
e20b043a
CS		 4751 LSM_HOOK_INIT(socket_connect, smack_socket_connect),
4752 LSM_HOOK_INIT(socket_sendmsg, smack_socket_sendmsg),
4753 LSM_HOOK_INIT(socket_sock_rcv_skb, smack_socket_sock_rcv_skb),
4754 LSM_HOOK_INIT(socket_getpeersec_stream, smack_socket_getpeersec_stream),
4755 LSM_HOOK_INIT(socket_getpeersec_dgram, smack_socket_getpeersec_dgram),
4756 LSM_HOOK_INIT(sk_alloc_security, smack_sk_alloc_security),
4757 LSM_HOOK_INIT(sk_free_security, smack_sk_free_security),
4758 LSM_HOOK_INIT(sock_graft, smack_sock_graft),
4759 LSM_HOOK_INIT(inet_conn_request, smack_inet_conn_request),
4760 LSM_HOOK_INIT(inet_csk_clone, smack_inet_csk_clone),
d20bdda6 4761
e114e473
CS		 4762 /* key management security hooks */
4763#ifdef CONFIG_KEYS
e20b043a
CS		 4764 LSM_HOOK_INIT(key_alloc, smack_key_alloc),
4765 LSM_HOOK_INIT(key_free, smack_key_free),
4766 LSM_HOOK_INIT(key_permission, smack_key_permission),
4767 LSM_HOOK_INIT(key_getsecurity, smack_key_getsecurity),
e114e473 4768#endif /* CONFIG_KEYS */
d20bdda6
AD		 4769
4770 /* Audit hooks */
4771#ifdef CONFIG_AUDIT
e20b043a
CS		 4772 LSM_HOOK_INIT(audit_rule_init, smack_audit_rule_init),
4773 LSM_HOOK_INIT(audit_rule_known, smack_audit_rule_known),
4774 LSM_HOOK_INIT(audit_rule_match, smack_audit_rule_match),
d20bdda6
AD		 4775#endif /* CONFIG_AUDIT */
4776
e20b043a
CS		 4777 LSM_HOOK_INIT(ismaclabel, smack_ismaclabel),
4778 LSM_HOOK_INIT(secid_to_secctx, smack_secid_to_secctx),
4779 LSM_HOOK_INIT(secctx_to_secid, smack_secctx_to_secid),
e20b043a
CS		 4780 LSM_HOOK_INIT(inode_notifysecctx, smack_inode_notifysecctx),
4781 LSM_HOOK_INIT(inode_setsecctx, smack_inode_setsecctx),
4782 LSM_HOOK_INIT(inode_getsecctx, smack_inode_getsecctx),
d6d80cb5
CS		 4783 LSM_HOOK_INIT(inode_copy_up, smack_inode_copy_up),
4784 LSM_HOOK_INIT(inode_copy_up_xattr, smack_inode_copy_up_xattr),
4785 LSM_HOOK_INIT(dentry_create_files_as, smack_dentry_create_files_as),
e114e473
CS		 4786};
4787
7198e2ee 4788
86812bb0 4789static __init void init_smack_known_list(void)
7198e2ee 4790{
86812bb0
CS		 4791 /*
4792 * Initialize rule list locks
4793 */
4794 mutex_init(&smack_known_huh.smk_rules_lock);
4795 mutex_init(&smack_known_hat.smk_rules_lock);
4796 mutex_init(&smack_known_floor.smk_rules_lock);
4797 mutex_init(&smack_known_star.smk_rules_lock);
86812bb0
CS		 4798 mutex_init(&smack_known_web.smk_rules_lock);
4799 /*
4800 * Initialize rule lists
4801 */
4802 INIT_LIST_HEAD(&smack_known_huh.smk_rules);
4803 INIT_LIST_HEAD(&smack_known_hat.smk_rules);
4804 INIT_LIST_HEAD(&smack_known_star.smk_rules);
4805 INIT_LIST_HEAD(&smack_known_floor.smk_rules);
86812bb0
CS		 4806 INIT_LIST_HEAD(&smack_known_web.smk_rules);
4807 /*
4808 * Create the known labels list
4809 */
4d7cf4a1
TS		 4810 smk_insert_entry(&smack_known_huh);
4811 smk_insert_entry(&smack_known_hat);
4812 smk_insert_entry(&smack_known_star);
4813 smk_insert_entry(&smack_known_floor);
4d7cf4a1 4814 smk_insert_entry(&smack_known_web);
7198e2ee
EB		 4815}
4816
e114e473
CS		 4817/**
4818 * smack_init - initialize the smack system
4819 *
4820 * Returns 0
4821 */
4822static __init int smack_init(void)
4823{
d84f4f99 4824 struct cred *cred;
676dac4b 4825 struct task_smack *tsp;
d84f4f99 4826
b1d9e6b0 4827 if (!security_module_enable("smack"))
7898e1f8
CS		 4828 return 0;
4829
1a5b472b
R		 4830 smack_inode_cache = KMEM_CACHE(inode_smack, 0);
4831 if (!smack_inode_cache)
4832 return -ENOMEM;
4833
2f823ff8
CS		 4834 tsp = new_task_smack(&smack_known_floor, &smack_known_floor,
4835 GFP_KERNEL);
1a5b472b
R		 4836 if (tsp == NULL) {
4837 kmem_cache_destroy(smack_inode_cache);
676dac4b 4838 return -ENOMEM;
1a5b472b 4839 }
676dac4b 4840
d21b7b04
JB		 4841 smack_enabled = 1;
4842
21abb1ec
CS		 4843 pr_info("Smack: Initializing.\n");
4844#ifdef CONFIG_SECURITY_SMACK_NETFILTER
4845 pr_info("Smack: Netfilter enabled.\n");
4846#endif
4847#ifdef SMACK_IPV6_PORT_LABELING
4848 pr_info("Smack: IPv6 port labeling enabled.\n");
4849#endif
4850#ifdef SMACK_IPV6_SECMARK_LABELING
4851 pr_info("Smack: IPv6 Netfilter enabled.\n");
4852#endif
e114e473
CS		 4853
4854 /*
4855 * Set the security state for the initial task.
4856 */
d84f4f99 4857 cred = (struct cred *) current->cred;
676dac4b 4858 cred->security = tsp;
e114e473 4859
86812bb0
CS		 4860 /* initialize the smack_known_list */
4861 init_smack_known_list();
e114e473
CS		 4862
4863 /*
4864 * Register with LSM
4865 */
d69dece5 4866 security_add_hooks(smack_hooks, ARRAY_SIZE(smack_hooks), "smack");
e114e473
CS		 4867
4868 return 0;
4869}
4870
4871/*
4872 * Smack requires early initialization in order to label
4873 * all processes and objects when they are created.
4874 */
4875security_initcall(smack_init);
Linux 6.x block layer and io_uring tree(s)