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