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