1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Task credentials management - see Documentation/security/credentials.rst
3  *
4  * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7 
8 #define pr_fmt(fmt) "CRED: " fmt
9 
10 #include <linux/export.h>
11 #include <linux/cred.h>
12 #include <linux/slab.h>
13 #include <linux/sched.h>
14 #include <linux/sched/coredump.h>
15 #include <linux/key.h>
16 #include <linux/keyctl.h>
17 #include <linux/init_task.h>
18 #include <linux/security.h>
19 #include <linux/binfmts.h>
20 #include <linux/cn_proc.h>
21 #include <linux/uidgid.h>
22 
23 #if 0
24 #define kdebug(FMT, ...)						\
25 	printk("[%-5.5s%5u] " FMT "\n",					\
26 	       current->comm, current->pid, ##__VA_ARGS__)
27 #else
28 #define kdebug(FMT, ...)						\
29 do {									\
30 	if (0)								\
31 		no_printk("[%-5.5s%5u] " FMT "\n",			\
32 			  current->comm, current->pid, ##__VA_ARGS__);	\
33 } while (0)
34 #endif
35 
36 static struct kmem_cache *cred_jar;
37 
38 /* init to 2 - one for init_task, one to ensure it is never freed */
39 static struct group_info init_groups = { .usage = ATOMIC_INIT(2) };
40 
41 /*
42  * The initial credentials for the initial task
43  */
44 struct cred init_cred = {
45 	.usage			= ATOMIC_INIT(4),
46 	.uid			= GLOBAL_ROOT_UID,
47 	.gid			= GLOBAL_ROOT_GID,
48 	.suid			= GLOBAL_ROOT_UID,
49 	.sgid			= GLOBAL_ROOT_GID,
50 	.euid			= GLOBAL_ROOT_UID,
51 	.egid			= GLOBAL_ROOT_GID,
52 	.fsuid			= GLOBAL_ROOT_UID,
53 	.fsgid			= GLOBAL_ROOT_GID,
54 	.securebits		= SECUREBITS_DEFAULT,
55 	.cap_inheritable	= CAP_EMPTY_SET,
56 	.cap_permitted		= CAP_FULL_SET,
57 	.cap_effective		= CAP_FULL_SET,
58 	.cap_bset		= CAP_FULL_SET,
59 	.user			= INIT_USER,
60 	.user_ns		= &init_user_ns,
61 	.group_info		= &init_groups,
62 	.ucounts		= &init_ucounts,
63 };
64 
65 /*
66  * The RCU callback to actually dispose of a set of credentials
67  */
put_cred_rcu(struct rcu_head * rcu)68 static void put_cred_rcu(struct rcu_head *rcu)
69 {
70 	struct cred *cred = container_of(rcu, struct cred, rcu);
71 
72 	kdebug("put_cred_rcu(%p)", cred);
73 
74 	if (atomic_long_read(&cred->usage) != 0)
75 		panic("CRED: put_cred_rcu() sees %p with usage %ld\n",
76 		      cred, atomic_long_read(&cred->usage));
77 
78 	security_cred_free(cred);
79 	key_put(cred->session_keyring);
80 	key_put(cred->process_keyring);
81 	key_put(cred->thread_keyring);
82 	key_put(cred->request_key_auth);
83 	if (cred->group_info)
84 		put_group_info(cred->group_info);
85 	free_uid(cred->user);
86 	if (cred->ucounts)
87 		put_ucounts(cred->ucounts);
88 	put_user_ns(cred->user_ns);
89 	kmem_cache_free(cred_jar, cred);
90 }
91 
92 /**
93  * __put_cred - Destroy a set of credentials
94  * @cred: The record to release
95  *
96  * Destroy a set of credentials on which no references remain.
97  */
__put_cred(struct cred * cred)98 void __put_cred(struct cred *cred)
99 {
100 	kdebug("__put_cred(%p{%ld})", cred,
101 	       atomic_long_read(&cred->usage));
102 
103 	BUG_ON(atomic_long_read(&cred->usage) != 0);
104 	BUG_ON(cred == current->cred);
105 	BUG_ON(cred == current->real_cred);
106 
107 	if (cred->non_rcu)
108 		put_cred_rcu(&cred->rcu);
109 	else
110 		call_rcu(&cred->rcu, put_cred_rcu);
111 }
112 EXPORT_SYMBOL(__put_cred);
113 
114 /*
115  * Clean up a task's credentials when it exits
116  */
exit_creds(struct task_struct * tsk)117 void exit_creds(struct task_struct *tsk)
118 {
119 	struct cred *cred;
120 
121 	kdebug("exit_creds(%u,%p,%p,{%ld})", tsk->pid, tsk->real_cred, tsk->cred,
122 	       atomic_long_read(&tsk->cred->usage));
123 
124 	cred = (struct cred *) tsk->real_cred;
125 	tsk->real_cred = NULL;
126 	put_cred(cred);
127 
128 	cred = (struct cred *) tsk->cred;
129 	tsk->cred = NULL;
130 	put_cred(cred);
131 
132 #ifdef CONFIG_KEYS_REQUEST_CACHE
133 	key_put(tsk->cached_requested_key);
134 	tsk->cached_requested_key = NULL;
135 #endif
136 }
137 
138 /**
139  * get_task_cred - Get another task's objective credentials
140  * @task: The task to query
141  *
142  * Get the objective credentials of a task, pinning them so that they can't go
143  * away.  Accessing a task's credentials directly is not permitted.
144  *
145  * The caller must also make sure task doesn't get deleted, either by holding a
146  * ref on task or by holding tasklist_lock to prevent it from being unlinked.
147  */
get_task_cred(struct task_struct * task)148 const struct cred *get_task_cred(struct task_struct *task)
149 {
150 	const struct cred *cred;
151 
152 	rcu_read_lock();
153 
154 	do {
155 		cred = __task_cred((task));
156 		BUG_ON(!cred);
157 	} while (!get_cred_rcu(cred));
158 
159 	rcu_read_unlock();
160 	return cred;
161 }
162 EXPORT_SYMBOL(get_task_cred);
163 
164 /*
165  * Allocate blank credentials, such that the credentials can be filled in at a
166  * later date without risk of ENOMEM.
167  */
cred_alloc_blank(void)168 struct cred *cred_alloc_blank(void)
169 {
170 	struct cred *new;
171 
172 	new = kmem_cache_zalloc(cred_jar, GFP_KERNEL);
173 	if (!new)
174 		return NULL;
175 
176 	atomic_long_set(&new->usage, 1);
177 	if (security_cred_alloc_blank(new, GFP_KERNEL_ACCOUNT) < 0)
178 		goto error;
179 
180 	return new;
181 
182 error:
183 	abort_creds(new);
184 	return NULL;
185 }
186 
187 /**
188  * prepare_creds - Prepare a new set of credentials for modification
189  *
190  * Prepare a new set of task credentials for modification.  A task's creds
191  * shouldn't generally be modified directly, therefore this function is used to
192  * prepare a new copy, which the caller then modifies and then commits by
193  * calling commit_creds().
194  *
195  * Preparation involves making a copy of the objective creds for modification.
196  *
197  * Returns a pointer to the new creds-to-be if successful, NULL otherwise.
198  *
199  * Call commit_creds() or abort_creds() to clean up.
200  */
prepare_creds(void)201 struct cred *prepare_creds(void)
202 {
203 	struct task_struct *task = current;
204 	const struct cred *old;
205 	struct cred *new;
206 
207 	new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
208 	if (!new)
209 		return NULL;
210 
211 	kdebug("prepare_creds() alloc %p", new);
212 
213 	old = task->cred;
214 	memcpy(new, old, sizeof(struct cred));
215 
216 	new->non_rcu = 0;
217 	atomic_long_set(&new->usage, 1);
218 	get_group_info(new->group_info);
219 	get_uid(new->user);
220 	get_user_ns(new->user_ns);
221 
222 #ifdef CONFIG_KEYS
223 	key_get(new->session_keyring);
224 	key_get(new->process_keyring);
225 	key_get(new->thread_keyring);
226 	key_get(new->request_key_auth);
227 #endif
228 
229 #ifdef CONFIG_SECURITY
230 	new->security = NULL;
231 #endif
232 
233 	new->ucounts = get_ucounts(new->ucounts);
234 	if (!new->ucounts)
235 		goto error;
236 
237 	if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)
238 		goto error;
239 
240 	return new;
241 
242 error:
243 	abort_creds(new);
244 	return NULL;
245 }
246 EXPORT_SYMBOL(prepare_creds);
247 
248 /*
249  * Prepare credentials for current to perform an execve()
250  * - The caller must hold ->cred_guard_mutex
251  */
prepare_exec_creds(void)252 struct cred *prepare_exec_creds(void)
253 {
254 	struct cred *new;
255 
256 	new = prepare_creds();
257 	if (!new)
258 		return new;
259 
260 #ifdef CONFIG_KEYS
261 	/* newly exec'd tasks don't get a thread keyring */
262 	key_put(new->thread_keyring);
263 	new->thread_keyring = NULL;
264 
265 	/* inherit the session keyring; new process keyring */
266 	key_put(new->process_keyring);
267 	new->process_keyring = NULL;
268 #endif
269 
270 	new->suid = new->fsuid = new->euid;
271 	new->sgid = new->fsgid = new->egid;
272 
273 	return new;
274 }
275 
276 /*
277  * Copy credentials for the new process created by fork()
278  *
279  * We share if we can, but under some circumstances we have to generate a new
280  * set.
281  *
282  * The new process gets the current process's subjective credentials as its
283  * objective and subjective credentials
284  */
copy_creds(struct task_struct * p,unsigned long clone_flags)285 int copy_creds(struct task_struct *p, unsigned long clone_flags)
286 {
287 	struct cred *new;
288 	int ret;
289 
290 #ifdef CONFIG_KEYS_REQUEST_CACHE
291 	p->cached_requested_key = NULL;
292 #endif
293 
294 	if (
295 #ifdef CONFIG_KEYS
296 		!p->cred->thread_keyring &&
297 #endif
298 		clone_flags & CLONE_THREAD
299 	    ) {
300 		p->real_cred = get_cred(p->cred);
301 		get_cred(p->cred);
302 		kdebug("share_creds(%p{%ld})",
303 		       p->cred, atomic_long_read(&p->cred->usage));
304 		inc_rlimit_ucounts(task_ucounts(p), UCOUNT_RLIMIT_NPROC, 1);
305 		return 0;
306 	}
307 
308 	new = prepare_creds();
309 	if (!new)
310 		return -ENOMEM;
311 
312 	if (clone_flags & CLONE_NEWUSER) {
313 		ret = create_user_ns(new);
314 		if (ret < 0)
315 			goto error_put;
316 		ret = set_cred_ucounts(new);
317 		if (ret < 0)
318 			goto error_put;
319 	}
320 
321 #ifdef CONFIG_KEYS
322 	/* new threads get their own thread keyrings if their parent already
323 	 * had one */
324 	if (new->thread_keyring) {
325 		key_put(new->thread_keyring);
326 		new->thread_keyring = NULL;
327 		if (clone_flags & CLONE_THREAD)
328 			install_thread_keyring_to_cred(new);
329 	}
330 
331 	/* The process keyring is only shared between the threads in a process;
332 	 * anything outside of those threads doesn't inherit.
333 	 */
334 	if (!(clone_flags & CLONE_THREAD)) {
335 		key_put(new->process_keyring);
336 		new->process_keyring = NULL;
337 	}
338 #endif
339 
340 	p->cred = p->real_cred = get_cred(new);
341 	inc_rlimit_ucounts(task_ucounts(p), UCOUNT_RLIMIT_NPROC, 1);
342 	return 0;
343 
344 error_put:
345 	put_cred(new);
346 	return ret;
347 }
348 
cred_cap_issubset(const struct cred * set,const struct cred * subset)349 static bool cred_cap_issubset(const struct cred *set, const struct cred *subset)
350 {
351 	const struct user_namespace *set_ns = set->user_ns;
352 	const struct user_namespace *subset_ns = subset->user_ns;
353 
354 	/* If the two credentials are in the same user namespace see if
355 	 * the capabilities of subset are a subset of set.
356 	 */
357 	if (set_ns == subset_ns)
358 		return cap_issubset(subset->cap_permitted, set->cap_permitted);
359 
360 	/* The credentials are in a different user namespaces
361 	 * therefore one is a subset of the other only if a set is an
362 	 * ancestor of subset and set->euid is owner of subset or one
363 	 * of subsets ancestors.
364 	 */
365 	for (;subset_ns != &init_user_ns; subset_ns = subset_ns->parent) {
366 		if ((set_ns == subset_ns->parent)  &&
367 		    uid_eq(subset_ns->owner, set->euid))
368 			return true;
369 	}
370 
371 	return false;
372 }
373 
374 /**
375  * commit_creds - Install new credentials upon the current task
376  * @new: The credentials to be assigned
377  *
378  * Install a new set of credentials to the current task, using RCU to replace
379  * the old set.  Both the objective and the subjective credentials pointers are
380  * updated.  This function may not be called if the subjective credentials are
381  * in an overridden state.
382  *
383  * This function eats the caller's reference to the new credentials.
384  *
385  * Always returns 0 thus allowing this function to be tail-called at the end
386  * of, say, sys_setgid().
387  */
commit_creds(struct cred * new)388 int commit_creds(struct cred *new)
389 {
390 	struct task_struct *task = current;
391 	const struct cred *old = task->real_cred;
392 
393 	kdebug("commit_creds(%p{%ld})", new,
394 	       atomic_long_read(&new->usage));
395 
396 	BUG_ON(task->cred != old);
397 	BUG_ON(atomic_long_read(&new->usage) < 1);
398 
399 	get_cred(new); /* we will require a ref for the subj creds too */
400 
401 	/* dumpability changes */
402 	if (!uid_eq(old->euid, new->euid) ||
403 	    !gid_eq(old->egid, new->egid) ||
404 	    !uid_eq(old->fsuid, new->fsuid) ||
405 	    !gid_eq(old->fsgid, new->fsgid) ||
406 	    !cred_cap_issubset(old, new)) {
407 		if (task->mm)
408 			set_dumpable(task->mm, suid_dumpable);
409 		task->pdeath_signal = 0;
410 		/*
411 		 * If a task drops privileges and becomes nondumpable,
412 		 * the dumpability change must become visible before
413 		 * the credential change; otherwise, a __ptrace_may_access()
414 		 * racing with this change may be able to attach to a task it
415 		 * shouldn't be able to attach to (as if the task had dropped
416 		 * privileges without becoming nondumpable).
417 		 * Pairs with a read barrier in __ptrace_may_access().
418 		 */
419 		smp_wmb();
420 	}
421 
422 	/* alter the thread keyring */
423 	if (!uid_eq(new->fsuid, old->fsuid))
424 		key_fsuid_changed(new);
425 	if (!gid_eq(new->fsgid, old->fsgid))
426 		key_fsgid_changed(new);
427 
428 	/* do it
429 	 * RLIMIT_NPROC limits on user->processes have already been checked
430 	 * in set_user().
431 	 */
432 	if (new->user != old->user || new->user_ns != old->user_ns)
433 		inc_rlimit_ucounts(new->ucounts, UCOUNT_RLIMIT_NPROC, 1);
434 	rcu_assign_pointer(task->real_cred, new);
435 	rcu_assign_pointer(task->cred, new);
436 	if (new->user != old->user || new->user_ns != old->user_ns)
437 		dec_rlimit_ucounts(old->ucounts, UCOUNT_RLIMIT_NPROC, 1);
438 
439 	/* send notifications */
440 	if (!uid_eq(new->uid,   old->uid)  ||
441 	    !uid_eq(new->euid,  old->euid) ||
442 	    !uid_eq(new->suid,  old->suid) ||
443 	    !uid_eq(new->fsuid, old->fsuid))
444 		proc_id_connector(task, PROC_EVENT_UID);
445 
446 	if (!gid_eq(new->gid,   old->gid)  ||
447 	    !gid_eq(new->egid,  old->egid) ||
448 	    !gid_eq(new->sgid,  old->sgid) ||
449 	    !gid_eq(new->fsgid, old->fsgid))
450 		proc_id_connector(task, PROC_EVENT_GID);
451 
452 	/* release the old obj and subj refs both */
453 	put_cred(old);
454 	put_cred(old);
455 	return 0;
456 }
457 EXPORT_SYMBOL(commit_creds);
458 
459 /**
460  * abort_creds - Discard a set of credentials and unlock the current task
461  * @new: The credentials that were going to be applied
462  *
463  * Discard a set of credentials that were under construction and unlock the
464  * current task.
465  */
abort_creds(struct cred * new)466 void abort_creds(struct cred *new)
467 {
468 	kdebug("abort_creds(%p{%ld})", new,
469 	       atomic_long_read(&new->usage));
470 
471 	BUG_ON(atomic_long_read(&new->usage) < 1);
472 	put_cred(new);
473 }
474 EXPORT_SYMBOL(abort_creds);
475 
476 /**
477  * override_creds - Override the current process's subjective credentials
478  * @new: The credentials to be assigned
479  *
480  * Install a set of temporary override subjective credentials on the current
481  * process, returning the old set for later reversion.
482  */
override_creds(const struct cred * new)483 const struct cred *override_creds(const struct cred *new)
484 {
485 	const struct cred *old = current->cred;
486 
487 	kdebug("override_creds(%p{%ld})", new,
488 	       atomic_long_read(&new->usage));
489 
490 	/*
491 	 * NOTE! This uses 'get_new_cred()' rather than 'get_cred()'.
492 	 *
493 	 * That means that we do not clear the 'non_rcu' flag, since
494 	 * we are only installing the cred into the thread-synchronous
495 	 * '->cred' pointer, not the '->real_cred' pointer that is
496 	 * visible to other threads under RCU.
497 	 */
498 	get_new_cred((struct cred *)new);
499 	rcu_assign_pointer(current->cred, new);
500 
501 	kdebug("override_creds() = %p{%ld}", old,
502 	       atomic_long_read(&old->usage));
503 	return old;
504 }
505 EXPORT_SYMBOL(override_creds);
506 
507 /**
508  * revert_creds - Revert a temporary subjective credentials override
509  * @old: The credentials to be restored
510  *
511  * Revert a temporary set of override subjective credentials to an old set,
512  * discarding the override set.
513  */
revert_creds(const struct cred * old)514 void revert_creds(const struct cred *old)
515 {
516 	const struct cred *override = current->cred;
517 
518 	kdebug("revert_creds(%p{%ld})", old,
519 	       atomic_long_read(&old->usage));
520 
521 	rcu_assign_pointer(current->cred, old);
522 	put_cred(override);
523 }
524 EXPORT_SYMBOL(revert_creds);
525 
526 /**
527  * cred_fscmp - Compare two credentials with respect to filesystem access.
528  * @a: The first credential
529  * @b: The second credential
530  *
531  * cred_cmp() will return zero if both credentials have the same
532  * fsuid, fsgid, and supplementary groups.  That is, if they will both
533  * provide the same access to files based on mode/uid/gid.
534  * If the credentials are different, then either -1 or 1 will
535  * be returned depending on whether @a comes before or after @b
536  * respectively in an arbitrary, but stable, ordering of credentials.
537  *
538  * Return: -1, 0, or 1 depending on comparison
539  */
cred_fscmp(const struct cred * a,const struct cred * b)540 int cred_fscmp(const struct cred *a, const struct cred *b)
541 {
542 	struct group_info *ga, *gb;
543 	int g;
544 
545 	if (a == b)
546 		return 0;
547 	if (uid_lt(a->fsuid, b->fsuid))
548 		return -1;
549 	if (uid_gt(a->fsuid, b->fsuid))
550 		return 1;
551 
552 	if (gid_lt(a->fsgid, b->fsgid))
553 		return -1;
554 	if (gid_gt(a->fsgid, b->fsgid))
555 		return 1;
556 
557 	ga = a->group_info;
558 	gb = b->group_info;
559 	if (ga == gb)
560 		return 0;
561 	if (ga == NULL)
562 		return -1;
563 	if (gb == NULL)
564 		return 1;
565 	if (ga->ngroups < gb->ngroups)
566 		return -1;
567 	if (ga->ngroups > gb->ngroups)
568 		return 1;
569 
570 	for (g = 0; g < ga->ngroups; g++) {
571 		if (gid_lt(ga->gid[g], gb->gid[g]))
572 			return -1;
573 		if (gid_gt(ga->gid[g], gb->gid[g]))
574 			return 1;
575 	}
576 	return 0;
577 }
578 EXPORT_SYMBOL(cred_fscmp);
579 
set_cred_ucounts(struct cred * new)580 int set_cred_ucounts(struct cred *new)
581 {
582 	struct ucounts *new_ucounts, *old_ucounts = new->ucounts;
583 
584 	/*
585 	 * This optimization is needed because alloc_ucounts() uses locks
586 	 * for table lookups.
587 	 */
588 	if (old_ucounts->ns == new->user_ns && uid_eq(old_ucounts->uid, new->uid))
589 		return 0;
590 
591 	if (!(new_ucounts = alloc_ucounts(new->user_ns, new->uid)))
592 		return -EAGAIN;
593 
594 	new->ucounts = new_ucounts;
595 	put_ucounts(old_ucounts);
596 
597 	return 0;
598 }
599 
600 /*
601  * initialise the credentials stuff
602  */
cred_init(void)603 void __init cred_init(void)
604 {
605 	/* allocate a slab in which we can store credentials */
606 	cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), 0,
607 			SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
608 }
609 
610 /**
611  * prepare_kernel_cred - Prepare a set of credentials for a kernel service
612  * @daemon: A userspace daemon to be used as a reference
613  *
614  * Prepare a set of credentials for a kernel service.  This can then be used to
615  * override a task's own credentials so that work can be done on behalf of that
616  * task that requires a different subjective context.
617  *
618  * @daemon is used to provide a base cred, with the security data derived from
619  * that; if this is "&init_task", they'll be set to 0, no groups, full
620  * capabilities, and no keys.
621  *
622  * The caller may change these controls afterwards if desired.
623  *
624  * Returns the new credentials or NULL if out of memory.
625  */
prepare_kernel_cred(struct task_struct * daemon)626 struct cred *prepare_kernel_cred(struct task_struct *daemon)
627 {
628 	const struct cred *old;
629 	struct cred *new;
630 
631 	if (WARN_ON_ONCE(!daemon))
632 		return NULL;
633 
634 	new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
635 	if (!new)
636 		return NULL;
637 
638 	kdebug("prepare_kernel_cred() alloc %p", new);
639 
640 	old = get_task_cred(daemon);
641 
642 	*new = *old;
643 	new->non_rcu = 0;
644 	atomic_long_set(&new->usage, 1);
645 	get_uid(new->user);
646 	get_user_ns(new->user_ns);
647 	get_group_info(new->group_info);
648 
649 #ifdef CONFIG_KEYS
650 	new->session_keyring = NULL;
651 	new->process_keyring = NULL;
652 	new->thread_keyring = NULL;
653 	new->request_key_auth = NULL;
654 	new->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
655 #endif
656 
657 #ifdef CONFIG_SECURITY
658 	new->security = NULL;
659 #endif
660 	new->ucounts = get_ucounts(new->ucounts);
661 	if (!new->ucounts)
662 		goto error;
663 
664 	if (security_prepare_creds(new, old, GFP_KERNEL_ACCOUNT) < 0)
665 		goto error;
666 
667 	put_cred(old);
668 	return new;
669 
670 error:
671 	put_cred(new);
672 	put_cred(old);
673 	return NULL;
674 }
675 EXPORT_SYMBOL(prepare_kernel_cred);
676 
677 /**
678  * set_security_override - Set the security ID in a set of credentials
679  * @new: The credentials to alter
680  * @secid: The LSM security ID to set
681  *
682  * Set the LSM security ID in a set of credentials so that the subjective
683  * security is overridden when an alternative set of credentials is used.
684  */
set_security_override(struct cred * new,u32 secid)685 int set_security_override(struct cred *new, u32 secid)
686 {
687 	return security_kernel_act_as(new, secid);
688 }
689 EXPORT_SYMBOL(set_security_override);
690 
691 /**
692  * set_security_override_from_ctx - Set the security ID in a set of credentials
693  * @new: The credentials to alter
694  * @secctx: The LSM security context to generate the security ID from.
695  *
696  * Set the LSM security ID in a set of credentials so that the subjective
697  * security is overridden when an alternative set of credentials is used.  The
698  * security ID is specified in string form as a security context to be
699  * interpreted by the LSM.
700  */
set_security_override_from_ctx(struct cred * new,const char * secctx)701 int set_security_override_from_ctx(struct cred *new, const char *secctx)
702 {
703 	u32 secid;
704 	int ret;
705 
706 	ret = security_secctx_to_secid(secctx, strlen(secctx), &secid);
707 	if (ret < 0)
708 		return ret;
709 
710 	return set_security_override(new, secid);
711 }
712 EXPORT_SYMBOL(set_security_override_from_ctx);
713 
714 /**
715  * set_create_files_as - Set the LSM file create context in a set of credentials
716  * @new: The credentials to alter
717  * @inode: The inode to take the context from
718  *
719  * Change the LSM file creation context in a set of credentials to be the same
720  * as the object context of the specified inode, so that the new inodes have
721  * the same MAC context as that inode.
722  */
set_create_files_as(struct cred * new,struct inode * inode)723 int set_create_files_as(struct cred *new, struct inode *inode)
724 {
725 	if (!uid_valid(inode->i_uid) || !gid_valid(inode->i_gid))
726 		return -EINVAL;
727 	new->fsuid = inode->i_uid;
728 	new->fsgid = inode->i_gid;
729 	return security_kernel_create_files_as(new, inode);
730 }
731 EXPORT_SYMBOL(set_create_files_as);
732