LCOV - code coverage report
Current view: top level - include/linux - cred.h (source / functions) Hit Total Coverage
Test: landlock.info Lines: 34 36 94.4 %
Date: 2021-04-22 12:43:58 Functions: 6 6 100.0 %

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

Generated by: LCOV version 1.14