Linux内核源码分析 -- 更新当前进程的 cred -- commit_creds
作者：互联网
浅析一下用来修改当前进程 cred 的函数 commit_creds
源码版本：Linux kernel 5.9.9
首先来看 cred 结构
/*
* The security context of a task
*
* The parts of the context break down into two categories:
*
* (1) The objective context of a task. These parts are used when some other
* task is attempting to affect this one.
*
* (2) The subjective context. These details are used when the task is acting
* upon another object, be that a file, a task, a key or whatever.
*
* Note that some members of this structure belong to both categories - the
* LSM security pointer for instance.
*
* A task has two security pointers. task->real_cred points to the objective
* context that defines that task's actual details. The objective part of this
* context is used whenever that task is acted upon.
*
* task->cred points to the subjective context that defines the details of how
* that task is going to act upon another object. This may be overridden
* temporarily to point to another security context, but normally points to the
* same context as task->real_cred.
*/
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed 使用这个 cred 的进程数*/
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task 创建进程的用户的 id ，不是创建可执行程序的用户 id*/
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task 保存的 euid 切换之前的 id，用于 euid 切换回来*/
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task euid 是进程运行过程中实时的 id*/
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription 创建进程的用户的 id 描述符*/
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
/* RCU deletion */
union {
int non_rcu; /* Can we skip RCU deletion? */
struct rcu_head rcu; /* RCU deletion hook */
};
} __randomize_layout;
commit_creds
/**
* commit_creds - Install new credentials upon the current task
* @new: The credentials to be assigned
*
* Install a new set of credentials to the current task, using RCU to replace
* the old set. Both the objective and the subjective credentials pointers are
* updated. This function may not be called if the subjective credentials are
* in an overridden state.
*
* This function eats the caller's reference to the new credentials.
*
* Always returns 0 thus allowing this function to be tail-called at the end
* of, say, sys_setgid().
*/
int commit_creds(struct cred *new)
{
// 获取当前进程的 task_struct
struct task_struct *task = current;
// 保存当前进程的 real_cred
const struct cred *old = task->real_cred;
kdebug("commit_creds(%p{%d,%d})", new,
atomic_read(&new->usage),
read_cred_subscribers(new));
// cred != real_cred 通常这个两个是一样的 当进程试图对一个其他对象（文件，进程，或者任何东西）进行操作的时候就是访问 real_cred
BUG_ON(task->cred != old);
#ifdef CONFIG_DEBUG_CREDENTIALS
// 使用 task->real_cred 的进程数小于 2，也就是说只能有一个进程使用这个 cred（real_cred 也是 cred 结构）
BUG_ON(read_cred_subscribers(old) < 2);
// 检查 cred 有没有被破坏，其实就是检查 cred 的魔数头 magic 字段是不是 CRED_MAGIC（默认 magic 是 CRED_MAGIC 值： 0x43736564），如果不是则认为 cred 可能被内存溢出覆盖
validate_creds(old);
validate_creds(new);
#endif
// 对 new 的引用数不小于 1
BUG_ON(atomic_read(&new->usage) < 1);
// get_cred 这个函数会先用 validate_creds 检查 cred 是否有效，
// 然后把 non_rcu 置 0
// 然后让 usage 加 1 表示引用这个 cred 的进程数 加 1
get_cred(new); /* we will require a ref for the subj creds too */
/* dumpability changes */
// 检查当前进程的 real_cred 和 new cred（要修改成的那个 cred）的各个字段是否一样，_eq 结尾的函数其实就是 比较两个值是否相等
if (!uid_eq(old->euid, new->euid) || // 检查 uid 是否相等
!gid_eq(old->egid, new->egid) || // 检查 egid 是否相等
!uid_eq(old->fsuid, new->fsuid) || // 检查 fsuid 是否相等
!gid_eq(old->fsgid, new->fsgid) || // 检查 fsgid 是否相等
!cred_cap_issubset(old, new)) { // 检查 new cres 的 namespace 是不是 old cred 的 namespace 的子集
// 如果当前进程的 mm_struct 不是 NULL
if (task->mm)
set_dumpable(task->mm, suid_dumpable); // 设置 mm_struct 的 flag，加上 suid_dumpable 标志，表示 接受到 coredump 信号时生成 coredump
task->pdeath_signal = 0;
/*
* If a task drops privileges and becomes nondumpable,
* the dumpability change must become visible before
* the credential change; otherwise, a __ptrace_may_access()
* racing with this change may be able to attach to a task it
* shouldn't be able to attach to (as if the task had dropped
* privileges without becoming nondumpable).
* Pairs with a read barrier in __ptrace_may_access().
*/
// sfence 内存屏障
smp_wmb();
}
/* alter the thread keyring */
// 如果 new cred 的文件系统的 uid 和 gid 和目前进程的文件系统的 uid 和 gid 不一样则
if (!uid_eq(new->fsuid, old->fsuid))
key_fsuid_changed(new); // 更新 new 的 thread_keyring->uid 为 new->fsuid
if (!gid_eq(new->fsgid, old->fsgid))
key_fsgid_changed(new); // // 更新 new 的 thread_keyring->gid 为 new->fsgid
/* do it
* RLIMIT_NPROC limits on user->processes have already been checked
* in set_user().
*/
// new 的订阅进程 ubscribers 加 2
alter_cred_subscribers(new, 2);
// 如果 new cres 和 old cred 所属的 用户 不一样（对，就是你理解的系统里面的那个用户，每个 uid 就是一个 用户），user 是一个 user_struct，每个用户都有一个，里面记录的 processes 表示这个用户有多少个进程
if (new->user != old->user)
atomic_inc(&new->user->processes); // 既然 old cred 和 new cred 不是属于同一个用户，那么当前进程 使用 new cred 的时候 cred 对应的用户所有的进程数肯定要加 1（如果有点绕，仔细想想就能想通了）
// cred 和 real_cred 是 rcu 变量，是个指针，所以需要用 rcu_assign_pointer 去更新
rcu_assign_pointer(task->real_cred, new); // task->real_cred = new
rcu_assign_pointer(task->cred, new); // task->cred = new
// 这里检查有没有设置成功，因为 old 是指向当前进程的 real_cred 的，上面我们更新了 real_cred 为 new，所以这两个是一样的现在，都是指向 new cred
// 如果没有更新成功
if (new->user != old->user)
atomic_dec(&old->user->processes); // 用户进程数 减 1 ，因为上面我们加 1
// 操作结束 new 的订阅进程 ubscribers 减 2（或者说是加上 -2），对应上面那个加 2
alter_cred_subscribers(old, -2);
/* send notifications */
// 现在检查各个 uid 字段，还不一样就见鬼了
if (!uid_eq(new->uid, old->uid) ||
!uid_eq(new->euid, old->euid) ||
!uid_eq(new->suid, old->suid) ||
!uid_eq(new->fsuid, old->fsuid))
proc_id_connector(task, PROC_EVENT_UID);
if (!gid_eq(new->gid, old->gid) ||
!gid_eq(new->egid, old->egid) ||
!gid_eq(new->sgid, old->sgid) ||
!gid_eq(new->fsgid, old->fsgid))
proc_id_connector(task, PROC_EVENT_GID);
/* release the old obj and subj refs both */
// 释放 old cred
put_cred(old); // 对 old cred 的引用 减 1
put_cred(old); // 对 old cred 的引用 减 1
return 0;
}
EXPORT_SYMBOL(commit_creds);
get_cred
/**
* get_cred - Get a reference on a set of credentials
* @cred: The credentials to reference
*
* Get a reference on the specified set of credentials. The caller must
* release the reference. If %NULL is passed, it is returned with no action.
*
* This is used to deal with a committed set of credentials. Although the
* pointer is const, this will temporarily discard the const and increment the
* usage count. The purpose of this is to attempt to catch at compile time the
* accidental alteration of a set of credentials that should be considered
* immutable.
*/
static inline const struct cred *get_cred(const struct cred *cred)
{
struct cred *nonconst_cred = (struct cred *) cred;
// 检查是不是 cred 一个有效的地址
if (!cred)
return cred;
// 验证 cred 的 magic
validate_creds(cred);
nonconst_cred->non_rcu = 0;
// usage 字段加 1
return get_new_cred(nonconst_cred);
}
get_new_cred
/**
* get_new_cred - Get a reference on a new set of credentials
* @cred: The new credentials to reference
*
* Get a reference on the specified set of new credentials. The caller must
* release the reference.
*/
static inline struct cred *get_new_cred(struct cred *cred)
{
// usage 字段加 1
atomic_inc(&cred->usage);
return cred;
}
cred_cap_issubset
static bool cred_cap_issubset(const struct cred *set, const struct cred *subset)
{
// 获取 cred 的 namespace
const struct user_namespace *set_ns = set->user_ns;
const struct user_namespace *subset_ns = subset->user_ns;
/* If the two credentials are in the same user namespace see if
* the capabilities of subset are a subset of set.
*/
// 如果这两个 cred 位于相同的 namespace
if (set_ns == subset_ns)
return cap_issubset(subset->cap_permitted, set->cap_permitted);
/* The credentials are in a different user namespaces
* therefore one is a subset of the other only if a set is an
* ancestor of subset and set->euid is owner of subset or one
* of subsets ancestors.
*/
// 遍历 namespace
for (;subset_ns != &init_user_ns; subset_ns = subset_ns->parent) {
// 如果 old cred 的 namespace 是 new cred 的 namespace 的先祖，并且 new 的 namespace 的实际所有者是 ord
if ((set_ns == subset_ns->parent) &&
uid_eq(subset_ns->owner, set->euid))
return true; // 也可以判定 new cred 的 namespace 是 ord cred 的 namespace 的子集
}
return false; // 如果遍历完所有的 namespace 没有符合的，说明 new cred 的 namespace 不是 old cred 的 namespace 的子集
}
put_cred
/**
* put_cred - Release a reference to a set of credentials
* @cred: The credentials to release
*
* Release a reference to a set of credentials, deleting them when the last ref
* is released. If %NULL is passed, nothing is done.
*
* This takes a const pointer to a set of credentials because the credentials
* on task_struct are attached by const pointers to prevent accidental
* alteration of otherwise immutable credential sets.
*/
static inline void put_cred(const struct cred *_cred)
{
struct cred *cred = (struct cred *) _cred;
if (cred) {
// 验证 cred 没有被破坏
validate_creds(cred);
// usage 减 1，如果 usage 为 0 则条件为真陷入 if
if (atomic_dec_and_test(&(cred)->usage))
__put_cred(cred); // 因为 usage 为 0，表示没有进程在使用这个 cred，直接销毁 cred
}
}
__put_cred
/**
* __put_cred - Destroy a set of credentials
* @cred: The record to release
*
* Destroy a set of credentials on which no references remain.
*/
void __put_cred(struct cred *cred)
{
kdebug("__put_cred(%p{%d,%d})", cred,
atomic_read(&cred->usage),
read_cred_subscribers(cred));
// 再次检查要销毁的 cred 的 usage
BUG_ON(atomic_read(&cred->usage) != 0);
#ifdef CONFIG_DEBUG_CREDENTIALS
// 检查查要销毁的 cred 的 subscribers
BUG_ON(read_cred_subscribers(cred) != 0);
// 把 cred 的 magic 更改成 CRED_MAGIC_DEAD 表示 cred 不可用
cred->magic = CRED_MAGIC_DEAD;
cred->put_addr = __builtin_return_address(0);
#endif
// 要销毁的 cred 当然不能是当前进程使用的 cred
BUG_ON(cred == current->cred);
BUG_ON(cred == current->real_cred);
// 如果是使用 RCU deletion hook 的话 ，则可以直接调用 put_cred_rcu 函数
if (cred->non_rcu)
put_cred_rcu(&cred->rcu);
else
call_rcu(&cred->rcu, put_cred_rcu); // 不然需要使用 call_rcu 去找 put_cred_rcu 函数（ rcu 函数是串在一条 RCU deletion hook 链表上每个节点都是一个 rcu_head ）（大概是这样的，我也没深究，其实还是调用 put_cred_rcu 函数，反正就是在申请 cred 的时候有没有设置 hook 了，设置了可以直接调用，不然要使用 call_rcu 去找，毕竟 cred 是 rcu 变量，需要特定的方式去销毁）
}
EXPORT_SYMBOL(__put_cred);
其实后面的也没什么好分析的了
void security_cred_free(struct cred *cred)
{
/*
* There is a failure case in prepare_creds() that
* may result in a call here with ->security being NULL.
*/
if (unlikely(cred->security == NULL))
return;
call_void_hook(cred_free, cred);
kfree(cred->security);
cred->security = NULL;
}
/*
* The RCU callback to actually dispose of a set of credentials
*/
static void put_cred_rcu(struct rcu_head *rcu)
{
// 通过 rcu 字段的地址去找包含这个 rcu 的 cred 结构，这个 container_of 实际很巧妙我以前分析过就不展开了
struct cred *cred = container_of(rcu, struct cred, rcu);
kdebug("put_cred_rcu(%p)", cred);
#ifdef CONFIG_DEBUG_CREDENTIALS
if (cred->magic != CRED_MAGIC_DEAD ||
atomic_read(&cred->usage) != 0 ||
read_cred_subscribers(cred) != 0)
panic("CRED: put_cred_rcu() sees %p with"
" mag %x, put %p, usage %d, subscr %d\n",
cred, cred->magic, cred->put_addr,
atomic_read(&cred->usage),
read_cred_subscribers(cred));
#else
// 检查 usage，还有进程使用这个 cred 直接就 panic
if (atomic_read(&cred->usage) != 0)
panic("CRED: put_cred_rcu() sees %p with usage %d\n",
cred, atomic_read(&cred->usage));
#endif
// 使用 kfree 释放 cred->security，并置 cred->security 为 NULL，防止 UAF
security_cred_free(cred);
// 先检查 keyring 的有效性，然后让 keyring 的 usage 减 1，跟 cred 一样，如果 usage 为 0 ，则销毁 keyring，因为 keyring 可以被多个 cred 使用（一个 keyring 对应多个 cred），所以才会有一个 usage 字段，现在销毁 这个 cred 如果是 最后一个使用这个 keyring 的，则销毁 cred 后销毁 keyring
key_put(cred->session_keyring);
key_put(cred->process_keyring);
key_put(cred->thread_keyring);
key_put(cred->request_key_auth);
// 一样，对 group_info 的 usage 减 1，跟 cred 一样，如果 usage 为 0 ，则销毁 group_info，因为 group_info 可以被多个 cred 使用（一个 group_info 对应多个 cred），所以才会有一个 usage 字段。。。。。。跟上面的 keyring 一样
if (cred->group_info)
put_group_info(cred->group_info);
// 释放 user_struct
free_uid(cred->user);
// 跟上面的 keyring group_info 一样
put_user_ns(cred->user_ns);
// 完成这些工作后，把 cred 放入 cred_jar，因为 cred 是个高频使用的数据结构，所以不是释放内存，而是把 cred 放入 一个缓存 cred_jar
kmem_cache_free(cred_jar, cred);
}
现在快凌晨 4 点了，困死了
# r00t @ FakeLinux in ~ [3:53:16]
$ date
Tue 23 Feb 2021 03:53:19 AM CST
后面的 检查释放 keyring，group_info，user_ns 不想一句一句分析代码了，道理都一样，先引用计数器减 1，为 0 说明这个结构没有在使用，就释放掉
over！
标签：task,old,struct,--,rcu,源码,Linux,new,cred 来源： https://www.cnblogs.com/crybaby/p/14433930.html