Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
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: 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: 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: if (atomic_dec_and_test(&(cred)->usage)) 249: __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 */ 376: