Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0-or-later */
2 : /* 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 : #ifndef _LINUX_CRED_H
9 : #define _LINUX_CRED_H
10 :
11 : #include <linux/capability.h>
12 : #include <linux/init.h>
13 : #include <linux/key.h>
14 : #include <linux/atomic.h>
15 : #include <linux/uidgid.h>
16 : #include <linux/sched.h>
17 : #include <linux/sched/user.h>
18 :
19 : struct cred;
20 : struct inode;
21 :
22 : /*
23 : * COW Supplementary groups list
24 : */
25 : struct group_info {
26 : atomic_t usage;
27 : int ngroups;
28 : kgid_t gid[];
29 : } __randomize_layout;
30 :
31 : /**
32 : * get_group_info - Get a reference to a group info structure
33 : * @group_info: The group info to reference
34 : *
35 : * This gets a reference to a set of supplementary groups.
36 : *
37 : * If the caller is accessing a task's credentials, they must hold the RCU read
38 : * lock when reading.
39 : */
40 : static inline struct group_info *get_group_info(struct group_info *gi)
41 : {
42 : atomic_inc(&gi->usage);
43 : return gi;
44 : }
45 :
46 : /**
47 : * put_group_info - Release a reference to a group info structure
48 : * @group_info: The group info to release
49 : */
50 : #define put_group_info(group_info) \
51 : do { \
52 : if (atomic_dec_and_test(&(group_info)->usage)) \
53 : groups_free(group_info); \
54 : } while (0)
55 :
56 : #ifdef CONFIG_MULTIUSER
57 : extern struct group_info *groups_alloc(int);
58 : extern void groups_free(struct group_info *);
59 :
60 : extern int in_group_p(kgid_t);
61 : extern int in_egroup_p(kgid_t);
62 : extern int groups_search(const struct group_info *, kgid_t);
63 :
64 : extern int set_current_groups(struct group_info *);
65 : extern void set_groups(struct cred *, struct group_info *);
66 : extern bool may_setgroups(void);
67 : extern void groups_sort(struct group_info *);
68 : #else
69 : static inline void groups_free(struct group_info *group_info)
70 : {
71 : }
72 :
73 : static inline int in_group_p(kgid_t grp)
74 : {
75 : return 1;
76 : }
77 : static inline int in_egroup_p(kgid_t grp)
78 : {
79 : return 1;
80 : }
81 : static inline int groups_search(const struct group_info *group_info, kgid_t grp)
82 : {
83 : return 1;
84 : }
85 : #endif
86 :
87 : /*
88 : * The security context of a task
89 : *
90 : * The parts of the context break down into two categories:
91 : *
92 : * (1) The objective context of a task. These parts are used when some other
93 : * task is attempting to affect this one.
94 : *
95 : * (2) The subjective context. These details are used when the task is acting
96 : * upon another object, be that a file, a task, a key or whatever.
97 : *
98 : * Note that some members of this structure belong to both categories - the
99 : * LSM security pointer for instance.
100 : *
101 : * A task has two security pointers. task->real_cred points to the objective
102 : * context that defines that task's actual details. The objective part of this
103 : * context is used whenever that task is acted upon.
104 : *
105 : * task->cred points to the subjective context that defines the details of how
106 : * that task is going to act upon another object. This may be overridden
107 : * temporarily to point to another security context, but normally points to the
108 : * same context as task->real_cred.
109 : */
110 : struct cred {
111 : atomic_t usage;
112 : #ifdef CONFIG_DEBUG_CREDENTIALS
113 : atomic_t subscribers; /* number of processes subscribed */
114 : void *put_addr;
115 : unsigned magic;
116 : #define CRED_MAGIC 0x43736564
117 : #define CRED_MAGIC_DEAD 0x44656144
118 : #endif
119 : kuid_t uid; /* real UID of the task */
120 : kgid_t gid; /* real GID of the task */
121 : kuid_t suid; /* saved UID of the task */
122 : kgid_t sgid; /* saved GID of the task */
123 : kuid_t euid; /* effective UID of the task */
124 : kgid_t egid; /* effective GID of the task */
125 : kuid_t fsuid; /* UID for VFS ops */
126 : kgid_t fsgid; /* GID for VFS ops */
127 : unsigned securebits; /* SUID-less security management */
128 : kernel_cap_t cap_inheritable; /* caps our children can inherit */
129 : kernel_cap_t cap_permitted; /* caps we're permitted */
130 : kernel_cap_t cap_effective; /* caps we can actually use */
131 : kernel_cap_t cap_bset; /* capability bounding set */
132 : kernel_cap_t cap_ambient; /* Ambient capability set */
133 : #ifdef CONFIG_KEYS
134 : unsigned char jit_keyring; /* default keyring to attach requested
135 : * keys to */
136 : struct key *session_keyring; /* keyring inherited over fork */
137 : struct key *process_keyring; /* keyring private to this process */
138 : struct key *thread_keyring; /* keyring private to this thread */
139 : struct key *request_key_auth; /* assumed request_key authority */
140 : #endif
141 : #ifdef CONFIG_SECURITY
142 : void *security; /* LSM security */
143 : #endif
144 : struct user_struct *user; /* real user ID subscription */
145 : struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
146 : struct ucounts *ucounts;
147 : struct group_info *group_info; /* supplementary groups for euid/fsgid */
148 : /* RCU deletion */
149 : union {
150 : int non_rcu; /* Can we skip RCU deletion? */
151 : struct rcu_head rcu; /* RCU deletion hook */
152 : };
153 : } __randomize_layout;
154 :
155 : extern void __put_cred(struct cred *);
156 : extern void exit_creds(struct task_struct *);
157 : extern int copy_creds(struct task_struct *, unsigned long);
158 : extern const struct cred *get_task_cred(struct task_struct *);
159 : extern struct cred *cred_alloc_blank(void);
160 : extern struct cred *prepare_creds(void);
161 : extern struct cred *prepare_exec_creds(void);
162 : extern int commit_creds(struct cred *);
163 : extern void abort_creds(struct cred *);
164 : extern const struct cred *override_creds(const struct cred *);
165 : extern void revert_creds(const struct cred *);
166 : extern struct cred *prepare_kernel_cred(struct task_struct *);
167 : extern int change_create_files_as(struct cred *, struct inode *);
168 : extern int set_security_override(struct cred *, u32);
169 : extern int set_security_override_from_ctx(struct cred *, const char *);
170 : extern int set_create_files_as(struct cred *, struct inode *);
171 : extern int cred_fscmp(const struct cred *, const struct cred *);
172 : extern void __init cred_init(void);
173 : extern int set_cred_ucounts(struct cred *);
174 :
175 : /*
176 : * check for validity of credentials
177 : */
178 : #ifdef CONFIG_DEBUG_CREDENTIALS
179 : extern void __noreturn __invalid_creds(const struct cred *, const char *, unsigned);
180 : extern void __validate_process_creds(struct task_struct *,
181 : const char *, unsigned);
182 :
183 : extern bool creds_are_invalid(const struct cred *cred);
184 :
185 : static inline void __validate_creds(const struct cred *cred,
186 : const char *file, unsigned line)
187 : {
188 : if (unlikely(creds_are_invalid(cred)))
189 : __invalid_creds(cred, file, line);
190 : }
191 :
192 : #define validate_creds(cred) \
193 : do { \
194 : __validate_creds((cred), __FILE__, __LINE__); \
195 : } while(0)
196 :
197 : #define validate_process_creds() \
198 : do { \
199 : __validate_process_creds(current, __FILE__, __LINE__); \
200 : } while(0)
201 :
202 : extern void validate_creds_for_do_exit(struct task_struct *);
203 : #else
204 : static inline void validate_creds(const struct cred *cred)
205 : {
206 : }
207 : static inline void validate_creds_for_do_exit(struct task_struct *tsk)
208 : {
209 : }
210 : static inline void validate_process_creds(void)
211 : {
212 : }
213 : #endif
214 :
215 : static inline bool cap_ambient_invariant_ok(const struct cred *cred)
216 : {
217 : return cap_issubset(cred->cap_ambient,
218 : cap_intersect(cred->cap_permitted,
219 : cred->cap_inheritable));
220 : }
221 :
222 : /**
223 : * get_new_cred - Get a reference on a new set of credentials
224 : * @cred: The new credentials to reference
225 : *
226 : * Get a reference on the specified set of new credentials. The caller must
227 : * release the reference.
228 : */
229 923338299 : static inline struct cred *get_new_cred(struct cred *cred)
230 : {
231 923338299 : atomic_inc(&cred->usage);
232 923275662 : return cred;
233 : }
234 :
235 : /**
236 : * get_cred - Get a reference on a set of credentials
237 : * @cred: The credentials to reference
238 : *
239 : * Get a reference on the specified set of credentials. The caller must
240 : * release the reference. If %NULL is passed, it is returned with no action.
241 : *
242 : * This is used to deal with a committed set of credentials. Although the
243 : * pointer is const, this will temporarily discard the const and increment the
244 : * usage count. The purpose of this is to attempt to catch at compile time the
245 : * accidental alteration of a set of credentials that should be considered
246 : * immutable.
247 : */
248 0 : static inline const struct cred *get_cred(const struct cred *cred)
249 : {
250 923335189 : struct cred *nonconst_cred = (struct cred *) cred;
251 923335189 : if (!cred)
252 : return cred;
253 923335189 : validate_creds(cred);
254 923335189 : nonconst_cred->non_rcu = 0;
255 923335189 : return get_new_cred(nonconst_cred);
256 : }
257 :
258 : static inline const struct cred *get_cred_rcu(const struct cred *cred)
259 : {
260 : struct cred *nonconst_cred = (struct cred *) cred;
261 : if (!cred)
262 : return NULL;
263 : if (!atomic_inc_not_zero(&nonconst_cred->usage))
264 : return NULL;
265 : validate_creds(cred);
266 : nonconst_cred->non_rcu = 0;
267 : return cred;
268 : }
269 :
270 : /**
271 : * put_cred - Release a reference to a set of credentials
272 : * @cred: The credentials to release
273 : *
274 : * Release a reference to a set of credentials, deleting them when the last ref
275 : * is released. If %NULL is passed, nothing is done.
276 : *
277 : * This takes a const pointer to a set of credentials because the credentials
278 : * on task_struct are attached by const pointers to prevent accidental
279 : * alteration of otherwise immutable credential sets.
280 : */
281 909692383 : static inline void put_cred(const struct cred *_cred)
282 : {
283 909692383 : struct cred *cred = (struct cred *) _cred;
284 :
285 909692383 : if (cred) {
286 909692383 : validate_creds(cred);
287 1826723087 : if (atomic_dec_and_test(&(cred)->usage))
288 21556742 : __put_cred(cred);
289 : }
290 917029911 : }
291 :
292 : /**
293 : * current_cred - Access the current task's subjective credentials
294 : *
295 : * Access the subjective credentials of the current task. RCU-safe,
296 : * since nobody else can modify it.
297 : */
298 : #define current_cred() \
299 : rcu_dereference_protected(current->cred, 1)
300 :
301 : /**
302 : * current_real_cred - Access the current task's objective credentials
303 : *
304 : * Access the objective credentials of the current task. RCU-safe,
305 : * since nobody else can modify it.
306 : */
307 : #define current_real_cred() \
308 : rcu_dereference_protected(current->real_cred, 1)
309 :
310 : /**
311 : * __task_cred - Access a task's objective credentials
312 : * @task: The task to query
313 : *
314 : * Access the objective credentials of a task. The caller must hold the RCU
315 : * readlock.
316 : *
317 : * The result of this function should not be passed directly to get_cred();
318 : * rather get_task_cred() should be used instead.
319 : */
320 : #define __task_cred(task) \
321 : rcu_dereference((task)->real_cred)
322 :
323 : /**
324 : * get_current_cred - Get the current task's subjective credentials
325 : *
326 : * Get the subjective credentials of the current task, pinning them so that
327 : * they can't go away. Accessing the current task's credentials directly is
328 : * not permitted.
329 : */
330 : #define get_current_cred() \
331 : (get_cred(current_cred()))
332 :
333 : /**
334 : * get_current_user - Get the current task's user_struct
335 : *
336 : * Get the user record of the current task, pinning it so that it can't go
337 : * away.
338 : */
339 : #define get_current_user() \
340 : ({ \
341 : struct user_struct *__u; \
342 : const struct cred *__cred; \
343 : __cred = current_cred(); \
344 : __u = get_uid(__cred->user); \
345 : __u; \
346 : })
347 :
348 : /**
349 : * get_current_groups - Get the current task's supplementary group list
350 : *
351 : * Get the supplementary group list of the current task, pinning it so that it
352 : * can't go away.
353 : */
354 : #define get_current_groups() \
355 : ({ \
356 : struct group_info *__groups; \
357 : const struct cred *__cred; \
358 : __cred = current_cred(); \
359 : __groups = get_group_info(__cred->group_info); \
360 : __groups; \
361 : })
362 :
363 : #define task_cred_xxx(task, xxx) \
364 : ({ \
365 : __typeof__(((struct cred *)NULL)->xxx) ___val; \
366 : rcu_read_lock(); \
367 : ___val = __task_cred((task))->xxx; \
368 : rcu_read_unlock(); \
369 : ___val; \
370 : })
371 :
372 : #define task_uid(task) (task_cred_xxx((task), uid))
373 : #define task_euid(task) (task_cred_xxx((task), euid))
374 : #define task_ucounts(task) (task_cred_xxx((task), ucounts))
375 :
376 : #define current_cred_xxx(xxx) \
377 : ({ \
378 : current_cred()->xxx; \
379 : })
380 :
381 : #define current_uid() (current_cred_xxx(uid))
382 : #define current_gid() (current_cred_xxx(gid))
383 : #define current_euid() (current_cred_xxx(euid))
384 : #define current_egid() (current_cred_xxx(egid))
385 : #define current_suid() (current_cred_xxx(suid))
386 : #define current_sgid() (current_cred_xxx(sgid))
387 : #define current_fsuid() (current_cred_xxx(fsuid))
388 : #define current_fsgid() (current_cred_xxx(fsgid))
389 : #define current_cap() (current_cred_xxx(cap_effective))
390 : #define current_user() (current_cred_xxx(user))
391 : #define current_ucounts() (current_cred_xxx(ucounts))
392 :
393 : extern struct user_namespace init_user_ns;
394 : #ifdef CONFIG_USER_NS
395 : #define current_user_ns() (current_cred_xxx(user_ns))
396 : #else
397 : static inline struct user_namespace *current_user_ns(void)
398 : {
399 : return &init_user_ns;
400 : }
401 : #endif
402 :
403 :
404 : #define current_uid_gid(_uid, _gid) \
405 : do { \
406 : const struct cred *__cred; \
407 : __cred = current_cred(); \
408 : *(_uid) = __cred->uid; \
409 : *(_gid) = __cred->gid; \
410 : } while(0)
411 :
412 : #define current_euid_egid(_euid, _egid) \
413 : do { \
414 : const struct cred *__cred; \
415 : __cred = current_cred(); \
416 : *(_euid) = __cred->euid; \
417 : *(_egid) = __cred->egid; \
418 : } while(0)
419 :
420 : #define current_fsuid_fsgid(_fsuid, _fsgid) \
421 : do { \
422 : const struct cred *__cred; \
423 : __cred = current_cred(); \
424 : *(_fsuid) = __cred->fsuid; \
425 : *(_fsgid) = __cred->fsgid; \
426 : } while(0)
427 :
428 : #endif /* _LINUX_CRED_H */
|
