[kernel] 带着问题看源码 —— setreuid 何时更新 saved-set-uid (SUID)

梁泳

前言

在写《[apue] 进程控制那些事儿》/"进程创建"/"更改进程用户 ID 和组 ID"一节时，发现 setreuid 更新实际用户 ID (RUID) 或有效用户 ID (EUID) 时，保存的设置用户 ID (saved set-user-id SUID) 只会随 EUID 变更，并不像 man 上说的会随 RUID 变更 (man setreuid)：

1.        If the real user ID is set (i.e., ruid is not -1) or the effective user ID is set to a value not equal to  the
2.        previous real user ID, the saved set-user-ID will be set to the new effective user ID.

复制代码

下面是实测结果：

调用参数 (root 身份)	RUID	EUID	SUID
setreuid (bar, foo)	bar	foo	foo
setreuid (foo, bar)	foo	bar	bar
setreuid (-1, foo)	root	foo	foo
setreuid (bar, -1)	bar	root	root
setreuid (bar, bar)	bar	bar	bar
setreuid (foo, foo)	foo	foo	foo

特别是第 5 行 setreuid(bar, -1)，RUID 变更为了 bar，SUID 仍保持 root 不变。
为了解答这个问题，找来系统对应版本的 linux 源码查看：

1. > uname -a
2. Linux goodcitizen.bcc-gzhxy.baidu.com 3.10.0-1160.80.1.el7.x86_64 #1 SMP Tue Nov 8 15:48:59 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

复制代码

这里是 3.10。之前推荐过 CodeBrowser，新近又发现一个源码阅读神器 bootlin：

能选代码库版本，功能上也比 CodeBrowser 好用，比如关键字搜索，不仅准确，还能把定义、声明、成员、引用区分清楚，很好的解决了 CodeBrowser 找不到代码的痛点，墙裂推荐~
问题复现

在撸源码之前，先复习一下这个问题的来龙去脉，为节省读者时间，把之前的 demo 贴上来 (setuid)：

1. #include "../apue.h"
2. #include <sys/types.h>
3. #include <sys/file.h>
4. #include <sys/stat.h>
5. #include <unistd.h>
7. void print_ids ()
8. {
9.     uid_t ruid = 0;
10.     uid_t euid = 0;
11.     uid_t suid = 0;
12.     int ret = getresuid (&ruid, &euid, &suid);
13.     if (ret == 0)
14.         printf ("%d: ruid %d, euid %d, suid %d\n", getpid(), ruid, euid, suid);
15.     else
16.         err_sys ("getresuid");
17. }
19. int main (int argc, char *argv[])
20. {
21.     if (argc == 2)
22.     {
23.         char* uid=argv[1];
24.         int ret = setuid(atol(uid));
25.         if (ret != 0)
26.             err_sys ("setuid");
28.         print_ids();
29.     }
30.     else if (argc == 3)
31.     {
32.         char* ruid=argv[1];
33.         char* euid=argv[2];
34.         int ret = setreuid(atol(ruid), atol(euid));
35.         if (ret != 0)
36.             err_sys ("setreuid");
38.         print_ids();
39.     }
40.     else if (argc > 1)
41.     {
42.         char* uid=argv[1];
43.         int ret = seteuid(atol(uid));
44.         if (ret != 0)
45.             err_sys ("seteuid");
47.         print_ids();
48.     }
49.     else
50.     {
51.         print_ids();
52.     }
54.     return 0;
55. }

复制代码

做个简单说明：

• print_ids 打印当前进程 3 个权限ID：RUID / EUID / SUID，其中用到的 getresuid 仅 Linux 支持，能展示用户当前的 SUID 值
  
• ./setuid 123：触发 setuid 调用，并打印调用后的结果
  
• ./setuid 123 456：触发 setreuid 调用，并打印调用后的结果
  
• ./setuid 123 456 789：触发 seteuid 调用，并打印调用后的结果。注意仅第一个参数有用，后两个占位
  

通过传递 setuid 程序不同参数，就可以验证不同的接口了，这里只需验证 setreuid，固定传递两个参数即可。把测试脚本也贴上来 (setreuid.sh)：

1. #!/bin/sh
2. groupadd test
3. echo "create group ok"
5. useradd -g test foo
6. useradd -g test bar
7. foo_uid=$(id -u foo)
8. bar_uid=$(id -u bar)
9. echo "create user ok"
10. echo "    foo: ${foo_uid}"
11. echo "    bar: ${bar_uid}"
13. cd /tmp
14. #chown bar:test ./setuid
15. echo "test foo"
16. ./setuid
18. #chmod u+s ./setuid
19. #echo "test set-uid bar"
20. #su foo -c ./setuid
22. echo "test setreuid(bar, foo)"
23. ./setuid ${bar_uid} ${foo_uid}
25. echo "test setreuid(foo, bar)"
26. ./setuid ${foo_uid} ${bar_uid}
28. echo "test setreuid(-1, foo)"
29. ./setuid -1 ${foo_uid}
31. echo "test setreuid(bar, -1)"
32. ./setuid ${bar_uid} -1
34. echo "test setreuid(bar, bar)"
35. ./setuid ${bar_uid} ${bar_uid}
37. echo "test setreuid(foo, foo)"
38. ./setuid ${foo_uid} ${foo_uid}
40. userdel bar
41. userdel foo
42. echo "remove user ok"
44. rm -rf /home/bar
45. rm -rf /home/foo
46. echo "remove user home ok"
48. groupdel test
49. echo "delete group ok"

复制代码

自动创建测试账户并调用 setuid，验证了 6 种用例，需要使用超级用户身份启动：

1. > sudo sh setreuid.sh
2. create group ok
3. create user ok
4.     foo: 1003
5.     bar: 1004
6. test foo
7. 27253: ruid 0, euid 0, suid 0
8. test setreuid(bar, foo)
9. 27254: ruid 1004, euid 1003, suid 1003
10. test setreuid(foo, bar)
11. 27255: ruid 1003, euid 1004, suid 1004
12. test setreuid(-1, foo)
13. 27256: ruid 0, euid 1003, suid 1003
14. test setreuid(bar, -1)
15. 27257: ruid 1004, euid 0, suid 0
16. test setreuid(bar, bar)
17. 27258: ruid 1004, euid 1004, suid 1004
18. test setreuid(foo, foo)
19. 27259: ruid 1003, euid 1003, suid 1003
20. remove user ok
21. remove user home ok

复制代码

现象与表中列出的一致。
源码分析

在 kernel 3.10.0 版本中搜索 setreuid，没搜到，可能是 kernel 在系统函数上加了一堆宏识别不了，搜索 setuid 可以，它俩在同一个文件：

1. /*
2. * Unprivileged users may change the real uid to the effective uid
3. * or vice versa.  (BSD-style)
4. *
5. * If you set the real uid at all, or set the effective uid to a value not
6. * equal to the real uid, then the saved uid is set to the new effective uid.
7. *
8. * This makes it possible for a setuid program to completely drop its
9. * privileges, which is often a useful assertion to make when you are doing
10. * a security audit over a program.
11. *
12. * The general idea is that a program which uses just setreuid() will be
13. * 100% compatible with BSD.  A program which uses just setuid() will be
14. * 100% compatible with POSIX with saved IDs.
15. */
16. SYSCALL_DEFINE2(setreuid, uid_t, ruid, uid_t, euid)
17. {
18.         struct user_namespace *ns = current_user_ns();
19.         const struct cred *old;
20.         struct cred *new;
21.         int retval;
22.         kuid_t kruid, keuid;
24.         kruid = make_kuid(ns, ruid);
25.         keuid = make_kuid(ns, euid);
27.         if ((ruid != (uid_t) -1) && !uid_valid(kruid))
28.                 return -EINVAL;
29.         if ((euid != (uid_t) -1) && !uid_valid(keuid))
30.                 return -EINVAL;
32.         new = prepare_creds();
33.         if (!new)
34.                 return -ENOMEM;
35.         old = current_cred();
37.         retval = -EPERM;
38.         if (ruid != (uid_t) -1) {
39.                 new->uid = kruid;
40.                 if (!uid_eq(old->uid, kruid) &&
41.                     !uid_eq(old->euid, kruid) &&
42.                     !nsown_capable(CAP_SETUID))
43.                         goto error;
44.         }
46.         if (euid != (uid_t) -1) {
47.                 new->euid = keuid;
48.                 if (!uid_eq(old->uid, keuid) &&
49.                     !uid_eq(old->euid, keuid) &&
50.                     !uid_eq(old->suid, keuid) &&
51.                     !nsown_capable(CAP_SETUID))
52.                         goto error;
53.         }
55.         if (!uid_eq(new->uid, old->uid)) {
56.                 retval = set_user(new);
57.                 if (retval < 0)
58.                         goto error;
59.         }
60.         if (ruid != (uid_t) -1 ||
61.             (euid != (uid_t) -1 && !uid_eq(keuid, old->uid)))
62.                 new->suid = new->euid;
63.         new->fsuid = new->euid;
65.         retval = security_task_fix_setuid(new, old, LSM_SETID_RE);
66.         if (retval < 0)
67.                 goto error;
69.         return commit_creds(new);
71. error:
72.         abort_creds(new);
73.         return retval;
74. }

复制代码

代码不长没做删减，主体就是下面的框架：

1.     ...
2.         new = prepare_creds();
3.     ...
4.     old = current_cred();
5.     ...
6.         return commit_creds(new);
8. error:
9.         abort_creds(new);

复制代码

prepare_creds 返回的 new 代表新用户权限，会从当前权限复制一份；current_cred 返回的 old 代表原用户权限。经过对 new 的一番操作，如果成功就将它提交 (commit_creds)，原权限被替换；否则回滚 (abort_creds)，原权限不变。现在关注焦点转移到 new 的变更逻辑： 

1.         retval = -EPERM;
2.         if (ruid != (uid_t) -1) {
3.                 new->uid = kruid;
4.                 if (!uid_eq(old->uid, kruid) &&
5.                     !uid_eq(old->euid, kruid) &&
6.                     !nsown_capable(CAP_SETUID))
7.                         goto error;
8.         }

复制代码

 先看 ruid 参数，如果参数有效就将它设置到 new 的 uid，但需要同时满足以下条件：

• ruid == old->uid
  
• ruid == old->euid
  
• 原用户具有超级用户权限
  

否则出错。做为对比，再来看 euid 参数：

1.         if (euid != (uid_t) -1) {
2.                 new->euid = keuid;
3.                 if (!uid_eq(old->uid, keuid) &&
4.                     !uid_eq(old->euid, keuid) &&
5.                     !uid_eq(old->suid, keuid) &&
6.                     !nsown_capable(CAP_SETUID))
7.                         goto error;
8.         }

复制代码

与 ruid 差不多：

• euid == old->uid
  
• euid == old->euid
  
• euid == old->suid
  
• 原用户具有超级用户权限
  

多了一条规则，可以将 euid 设置为 old->suid。最后来看 SUID 的更新规则：

1.         if (ruid != (uid_t) -1 ||
2.             (euid != (uid_t) -1 && !uid_eq(keuid, old->uid)))
3.                 new->suid = new->euid;
4.         new->fsuid = new->euid;

复制代码

第三行准确无误的告诉我们，new ->suid 是固定被设置为 new->euid 的，时机是以下条件之一：

• ruid 有效
  
• euid 有效且 euid 与原 RUID 不同
  

看起来 ruid 参数只是影响 SUID 要不要从新 EUID 复制，即便 RUID 没变更、只要 ruid 参数有效就能产生这种作用。再回顾一下 man 的说明：

1.        If the real user ID is set (i.e., ruid is not -1) or the effective user ID is set to a value not equal to  the
2.        previous real user ID, the saved set-user-ID will be set to the new effective user ID.

复制代码

简直就是代码的"直译"，包括对 ruid 参数有效的说明、对 euid 参数与原 RUID 不同的说明、对 SUID 从新 EUID 复制的说明，一毛一样。之前把这里理解成 SUID 从 RUID 复制了，粗心大意了！
问题验证

了解 SUID 设置规则后，回头来看上面的表，有进一步的理解：

调用参数 (root 身份)	RUID	EUID	SUID	SUID 复制
setreuid (bar, foo)	bar *	foo *	foo	条件 I
setreuid (foo, bar)	foo *	bar *	bar	条件 I
setreuid (-1, foo)	root	foo *	foo	条件 II
setreuid (bar, -1)	bar *	root	root	条件 I
setreuid (bar, bar)	bar *	bar *	bar	条件 I
setreuid (foo, foo)	foo *	foo *	foo	条件 I

表中第二列中的星号表示 ruid 参数有效；第三列的星号表示 euid 变更 (!= old.uid)；由于 2 个条件之间是短路或的关系，第一个条件满足后就不再检测第二个条件，所以需要最后一列表示 SUID 复制最终是哪个条件触发的。看起来大部分是条件一 ruid 有效，这些用例对条件二的测试不足，需要构造一组新的用例进行验证。
考查这样一个场景，将 demo 设置为 set-user-id 为 root，以普通用户 foo 启动该进程后：RUID = foo、EUID = SUID = root，此时 RUID 与 EUID 不同，满足了上述的条件二；保持 RUID 无效 (-1) 不满足条件一，是不是就能走条件二了？下面来做个测试 (setreuid-setroot.sh)：

1. #!/bin/sh
2. groupadd test
3. echo "create group ok"
5. useradd -g test foo
6. useradd -g test bar
7. foo_uid=$(id -u foo)
8. bar_uid=$(id -u bar)
9. root_uid=0
10. echo "create user ok"
11. echo "    foo: ${foo_uid}"
12. echo "    bar: ${bar_uid}"
13. echo "    root: ${root_uid}"
15. cd /tmp
16. chown root:test ./setuid
17. echo "test foo"
18. su foo -c ./setuid
20. chmod u+s ./setuid
21. echo "test set-uid root"
22. su foo -c ./setuid
24. echo "test setreuid(-1, foo)"
25. su foo -c "./setuid -1 ${foo_uid}"
27. echo "test setreuid(-1, bar)"
28. su foo -c "./setuid -1 ${bar_uid}"
30. echo "test setreuid(foo, foo)"
31. su foo -c "./setuid ${foo_uid} ${foo_uid}"
33. echo "test setreuid(root, foo)"
34. su foo -c "./setuid ${root_uid} ${foo_uid}"
36. userdel foo
37. userdel bar
38. echo "remove user ok"
40. rm -rf /home/foo
41. rm -rf /home/bar
42. echo "remove user home ok"
44. groupdel test
45. echo "delete group ok"

复制代码

与之前的最大区别是，这里使用 foo 用户身份启动测试程序 (su foo -c)，且它是 set-user-id 为 root 的。验证以下 4 种 setreuid 用例：

1. > sudo sh setreuid-setroot.sh
2. create group ok
3. create user ok
4.     foo: 1003
5.     bar: 1004
6.     root: 0
7. test foo
8. 29332: ruid 1003, euid 1003, suid 1003
9. test set-uid root
10. 29345: ruid 1003, euid 0, suid 0
11. test setreuid(-1, foo)
12. 29357: ruid 1003, euid 1003, suid 0
13. test setreuid(-1, bar)
14. 29369: ruid 1003, euid 1004, suid 1004
15. test setreuid(foo, foo)
16. 29382: ruid 1003, euid 1003, suid 1003
17. test setreuid(root, foo)
18. 29396: ruid 0, euid 1003, suid 1003
19. remove user ok
20. remove user home ok
21. delete group ok

复制代码

清晰起见列表如下：

调用参数 (foo 身份 set-user-id  root)	RUID	EUID	SUID	SUID 复制
启动后	foo	root	root	n/a
setreuid (-1, foo)	foo	foo	root	未触发
setreuid (-1, bar)	foo	bar *	bar	条件 II
setreuid (foo, foo)	foo *	foo	foo	条件 I
setreuid (root, foo)	root *	foo	foo	条件 I

表中星号含义同前，下面分别解释：

• 第 3 行：仅设置 euid 为 foo，此时 ruid == -1 条件 1 不触发；euid == old.uid 条件 2 不触发，所以 SUID 保持 root 不变
  
• 第 4 行：仅设置 euid 为 bar，此时 ruid == -1 条件 1 不触发；euid != old.uid 条件 2 触发，所以 SUID 被复制为新 EUID：bar
  
• 第 5 行：同时设置 ruid 和 euid 为 foo，此时 ruid != -1 条件 1 触发；euid == old.uid 条件 2 不触发，所以 SUID 被复制为新 EUID：foo
  
• 第 6 行：设置 ruid 为 root，euid 为 foo，此时 ruid != -1 条件 1 触发；euid == old.uid 条件 2 不触发，最终 SUID 被复制为新 EUID：foo
  

与源码逻辑对应上了，正好也解释了原文《[apue] 进程控制那些事儿》中在这种场景下 setreuid(-1, foo) 用例中 SUID 保持为 root 的疑惑。
看看上表中第 3 行在 setreuid(-1,foo) 后的情形：RUID = EUID = foo，SUID = root，如果此时调用 setreuid(foo, -1) 按理说 SUID 会被更新为 foo，一试究竟：

1. uid_t ruid = 0;
2.     uid_t euid = 0;
3.     uid_t suid = 0;
4.     int ret = getresuid (&ruid, &euid, &suid);
5.     if (ret == 0)
6.     {
7.         printf ("%d: ruid %d, euid %d, suid %d\n", getpid(), ruid, euid, suid);
8. #ifdef TEST_UPDATE_RUID
9.         if (ruid == euid && euid != suid)
10.         {
11.             printf ("all uid same except suid %d, try to update ruid\n", ruid);
12.             ret = setreuid (ruid, -1);
13.             if (ret != 0)
14.                 err_sys ("setreuid");
15.             else
16.             {
17.                 getresuid (&ruid, &euid, &suid);
18.                 printf ("%d: ruid %d, euid %d, suid %d\n", getpid(), ruid, euid, suid);
19.             }
20.         }
21. #endif
23.     }
24.     else
25.         err_sys ("getresuid");

复制代码

在 print_ids 中检测到 RUID = EUID != SUID 时，将 RUID 重新设置一下，ruid 参数与原 RUID 一致。重新运行：

1. > sudo sh setreuid-setroot.sh
2. ...
3. test set-uid root
4. 29511: ruid 1003, euid 0, suid 0
5. test setreuid(-1, foo)
6. 29523: ruid 1003, euid 1003, suid 0
7. all uid same except suid 1003, try to update ruid
8. 29523: ruid 1003, euid 1003, suid 1003
9. ...

复制代码

SUID 果然随之变更了！这个用例更能说明问题，因为调用 setreuid 前后 RUID 与 EUID 没有发生改变，SUID 却因为 ruid 参数有效而发生了变更，有点意思。下面的表总结了上述过程：

调用参数 (foo 身份 set-user-id  root)	RUID	EUID	SUID	SUID 复制
启动后	foo	root	root	n/a
setreuid (-1, foo)	foo	foo	root	未触发
setreuid (foo, -1)	foo *	foo	foo	条件 I

这个表与之前不同的是所有 setreuid 调用均在一个进程中。
意义探寻

知其然，还要知其所以然，上面的探索只是第一步，对于 SUID 复制 EUID 的目的，《[apue] 进程控制那些事儿》已有讨论，这里聚焦 SUID 何时复制 EUID，按照直觉设计成下面的条件看起来更通顺：

1. ruid != old.uid || euid != old.euid

复制代码

为了解答这个疑问，就按照设想的条件重跑一下 setreuid 的所有用例：

调用参数 (root 身份)	RUID	EUID	SUID
setreuid (bar, foo)	bar	foo	foo
setreuid (foo, bar)	foo	bar	bar
setreuid (-1, foo)	root	foo	foo
setreuid (bar, -1)	bar	root	root
setreuid (bar, bar)	bar	bar	bar
setreuid (foo, foo)	foo	foo	foo

调用参数 (foo 身份 set-user-id  root)	RUID	EUID	SUID
启动后	foo	root	root
setreuid (-1, foo)	foo	foo	foo
setreuid (-1, bar)	foo	bar	bar
setreuid (foo, foo)	foo	foo	foo
setreuid (root, foo)	root	foo	foo

发现只有一个用例的结果会发生变化 (表中高亮字体)：进程 set-user-id 为 root 且以普通用户身份启动 setreuid(-1, foo)，从 SUID 不变到现在 SUID 跟随 EUID 改变，这导致整个进程变为普通进程失去重新转变为特权进程的机会。再看这个调用形式特别眼熟，这不就是 seteuid 嘛！它在改变 EUID 时是不希望 SUID 变更的，所以这下全明白了：setreuid 这样的设计是为了给 seteuid 切换特权身份留后门，从而有机会再切换回之前的身份。
结语

关于 seteuid，man 中有一段说明：

1.        Under  libc4,  libc5  and glibc 2.0 seteuid(euid) is equivalent to setreuid(-1, euid) and hence may change the
2.        saved set-user-ID.  Under glibc 2.1 and later it is equivalent to setresuid(-1, euid, -1) and hence  does  not
3.        change  the  saved  set-user-ID.  Analogous remarks hold for setegid(), with the difference that the change in
4.        implementation from setregid(-1, egid) to setresgid(-1, egid, -1) occurred in glibc 2.2 or 2.3 (dependeing  on
5.        the hardware architecture).

复制代码

大意是说 seteuid 到底等价于setreuid(-1,euid) 还是setresuid(-1,euid,-1)要看 glibc 版本，前者在改变 SUID 的逻辑上遵循上面的讨论；后者不遵循，或者说 SUID 不会随 EUID 变更。之前曾经比对过 setuid / setreuid / seteuid，并且推荐使用 seteuid，如果 seteuid 只是 setreuid 的分身，则它们的区别没想象那么大，只是写起来更方便一些。
后记

文章最后再推荐一波 bootlin：

代码库除了 kernel，还可以选择 freebsd、glibc、qemu、dpdk、grub、llvm、busybox 等，点击符号跳转，使用浏览器后退做调用栈回退，非常方便。
参考

[1]. https://elixir.bootlin.com

来源:https://www.cnblogs.com/goodcitizen/p/18111594/when_setreuid_updates_suid
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！