10

我正在尝试编写一个守护进程，它将使用 setuid 位以 root 身份启动，但随后很快恢复为运行该进程的用户。然而，守护进程需要保留将新线程设置为“实时”优先级的能力。我用来设置优先级的代码如下（创建后在线程中运行）：

struct sched_param sched_param;
memset(&sched_param, 0, sizeof(sched_param));
sched_param.sched_priority = 90;

if(-1 == sched_setscheduler(0, SCHED_FIFO, &sched_param)) {
  // If we get here, we have an error, for example "Operation not permitted"
}

但是，我遇到问题的部分是设置 uid，同时保留对sched_setscheduler.

我有一些代码在我的应用程序的主线程中接近启动时运行：

if (getgid() != getegid() || getuid() != geteuid()) {
  cap_value_t cap_values[] = {CAP_SYS_NICE};
  cap_t caps;
  caps = cap_get_proc();
  cap_set_flag(caps, CAP_PERMITTED, 1, cap_values, CAP_SET);
  cap_set_proc(caps);
  prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
  cap_free(caps);
  setegid(getgid());
  seteuid(getuid());
}

问题是，在运行此代码后，我在调用时得到“不允许操作”，sched_setscheduler正如上面评论中提到的那样。我究竟做错了什么？

4

2 回答 2

27

编辑以描述原始失败的原因：

Linux 中有三组能力：可继承、允许和有效。Inheritable 定义了哪些功能在exec(). 允许定义进程允许哪些能力。有效定义了当前有效的功能。

将进程的所有者或组从 root 更改为非 root 时，始终清除有效的能力集。

默认情况下，允许的能力集也被清除，但prctl(PR_SET_KEEPCAPS, 1L)在身份更改之前调用会告诉内核保持允许的集不变。

在进程将身份更改回非特权用户后，CAP_SYS_NICE必须将其添加到有效集合中。（它也必须设置在允许集中，所以如果你清除你的能力集，记得也要设置它。如果你只是修改当前的能力集，那么你知道它已经被设置了，因为你继承了它。）

这是我建议您应该遵循的程序：

  1. 保存真实用户 ID、真实组 ID 和补充组 ID：

     #define  _GNU_SOURCE
 #define  _BSD_SOURCE
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/capability.h>
 #include <sys/prctl.h>
 #include <grp.h>

 uid_t   user = getuid();
 gid_t   group = getgid();
 gid_t  *gid;
 int     gids, n;

 gids = getgroups(0, NULL);
 if (gids < 0) /* error */

 gid = malloc((gids + 1) * sizeof *gid);
 if (!gid) /* error */

 gids = getgroups(gids, gid);
 if (gids < 0) /* error */

  2. 过滤掉不必要的和特权的补充群体（偏执！）

     n = 0;
 while (n < gids)
     if (gid[n] == 0 || gid[n] == group)
         gid[n] = gid[--gids];
     else
         n++;

    因为您无法“清除”补充组 ID（仅请求当前编号），所以请确保列表永远不会为空。您可以随时将真实组 ID 添加到补充列表以使其非空。

     if (gids < 1) {
     gid[0] = group;
     gids = 1;
 }

  3. 将真实有效的用户ID切换为root

     if (setresuid(0, 0, 0)) /* error */

  4. 在集合中设置CAP_SYS_NICE能力CAP_PERMITTED。我更喜欢清除整个集合，并且只保留此方法工作所需的四个功能（稍后，删除除 CAP_SYS_NICE 之外的所有功能）：

     cap_value_t capability[4] = { CAP_SYS_NICE, CAP_SETUID, CAP_SETGID, CAP_SETPCAP };
 cap_t       capabilities;

 capabilities = cap_get_proc();
 if (cap_clear(capabilities)) /* error */
 if (cap_set_flag(capabilities, CAP_EFFECTIVE, 4, capability, CAP_SET)) /* error */
 if (cap_set_flag(capabilities, CAP_PERMITTED, 4, capability, CAP_SET)) /* error */
 if (cap_set_proc(capabilities)) /* error */

  5. 告诉内核您希望保留从 root 更改为非特权用户的功能；默认情况下，当从 root 身份更改为非 root 身份时，这些功能会被清零

     if (prctl(PR_SET_KEEPCAPS, 1L)) /* error */

  6. 将真实、有效和保存的组 ID 设置为最初保存的组 ID

     if (setresgid(group, group, group)) /* error */

  7. 设置补充组 ID

     if (setgroups(gids, gid)) /* error */

  8. 将真实、有效和保存的用户 ID 设置为最初保存的用户 ID

     if (setresuid(user, user, user)) /* error */

    在这一点上，您有效地放弃了 root 权限（不再能够重新获得它们），除了该CAP_SYS_NICE功能。由于从 root 用户到非 root 用户的转换，该功能永远不会生效；内核将始终清除此类转换上的有效功能集。

  9. CAP_SYS_NICE在CAP_PERMITTED和CAP_EFFECTIVE集合中设置能力

     if (cap_clear(capabilities)) /* error */
 if (cap_set_flag(capabilities, CAP_PERMITTED, 1, capability, CAP_SET))  /* error */
 if (cap_set_flag(capabilities, CAP_EFFECTIVE, 1, capability, CAP_SET))  /* error */
 if (cap_set_flag(capabilities, CAP_PERMITTED, 3, capability + 1, CAP_CLEAR))  /* error */
 if (cap_set_flag(capabilities, CAP_EFFECTIVE, 3, capability + 1, CAP_CLEAR))  /* error */

 if (cap_set_proc(capabilities)) /* error */

    请注意，后两个cap_set_flag()操作清除了不再需要的三个功能，因此只CAP_SYS_NICE保留第一个。

    此时不再需要功能描述符，因此释放它是个好主意。

     if (cap_free(capabilities)) /* error */

  10. 告诉内核您不希望保留对 root 的任何进一步更改的能力（再次，只是偏执狂）

     if (prctl(PR_SET_KEEPCAPS, 0L)) /* error */

libcap-dev安装软件包后，这适用于 x86-64，在 Xubuntu 12.04.1 LTS 上使用 GCC-4.6.3、libc6-2.15.0ubuntu10.3 和 linux-3.5.0-18 内核。

编辑添加：

您可以通过仅依赖作为 root 的有效用户 ID 来简化该过程，因为可执行文件是 setuid root。在这种情况下，您也无需担心补充组，因为 setuid root 只会影响有效用户 ID，不会影响其他任何内容。回到原来的真实用户，从技术上讲，您只需要在setresuid()过程结束时调用一次（setresgid()如果可执行文件也恰好被标记为 setgid root），将保存的和有效的用户（和组）ID 设置为真实用户。

但是，重新获得原始用户身份的情况很少见，而获得指定用户身份的情况很常见，这里的程序最初是为后者设计的。您将使用initgroups()为指定用户获取正确的补充组，依此类推。在这种情况下，仔细处理真实、有效和保存的用户和组 ID 以及补充组 ID 很重要，否则该过程将从执行该过程的用户那里继承补充组。

这里的过程是偏执的，但是当您处理安全敏感问题时，偏执并不是一件坏事。对于恢复到真实用户的情况，可以简化。

于 2013-03-17 编辑以显示一个简单的测试程序。这假定它安装了 setuid root，但它会删除所有特权和功能（除了 CAP_SYS_NICE，它是调度程序操作高于正常规则所必需的）。我减少了我喜欢做的“多余”操作，希望其他人觉得这更容易阅读。

#define  _GNU_SOURCE
#define  _BSD_SOURCE
#include <unistd.h>
#include <sys/types.h>
#include <sys/capability.h>
#include <sys/prctl.h>
#include <grp.h>
#include <errno.h>

#include <string.h>
#include <sched.h>
#include <stdio.h>


void test_priority(const char *const name, const int policy)
{
    const pid_t         me = getpid();
    struct sched_param  param;

    param.sched_priority = sched_get_priority_max(policy);
    printf("sched_get_priority_max(%s) = %d\n", name, param.sched_priority);
    if (sched_setscheduler(me, policy, &param) == -1)
        printf("sched_setscheduler(getpid(), %s, { %d }): %s.\n", name, param.sched_priority, strerror(errno));
    else
        printf("sched_setscheduler(getpid(), %s, { %d }): Ok.\n", name, param.sched_priority);

    param.sched_priority = sched_get_priority_min(policy);
    printf("sched_get_priority_min(%s) = %d\n", name, param.sched_priority);
    if (sched_setscheduler(me, policy, &param) == -1)
        printf("sched_setscheduler(getpid(), %s, { %d }): %s.\n", name, param.sched_priority, strerror(errno));
    else
        printf("sched_setscheduler(getpid(), %s, { %d }): Ok.\n", name, param.sched_priority);

}


int main(void)
{
    uid_t       user;
    cap_value_t root_caps[2] = { CAP_SYS_NICE, CAP_SETUID };
    cap_value_t user_caps[1] = { CAP_SYS_NICE };
    cap_t       capabilities;

    /* Get real user ID. */
    user = getuid();

    /* Get full root privileges. Normally being effectively root
     * (see man 7 credentials, User and Group Identifiers, for explanation
     *  for effective versus real identity) is enough, but some security
     * modules restrict actions by processes that are only effectively root.
     * To make sure we don't hit those problems, we switch to root fully. */
    if (setresuid(0, 0, 0)) {
        fprintf(stderr, "Cannot switch to root: %s.\n", strerror(errno));
        return 1;
    }

    /* Create an empty set of capabilities. */
    capabilities = cap_init();

    /* Capabilities have three subsets:
     *      INHERITABLE:    Capabilities permitted after an execv()
     *      EFFECTIVE:      Currently effective capabilities
     *      PERMITTED:      Limiting set for the two above.
     * See man 7 capabilities for details, Thread Capability Sets.
     *
     * We need the following capabilities:
     *      CAP_SYS_NICE    For nice(2), setpriority(2),
     *                      sched_setscheduler(2), sched_setparam(2),
     *                      sched_setaffinity(2), etc.
     *      CAP_SETUID      For setuid(), setresuid()
     * in the last two subsets. We do not need to retain any capabilities
     * over an exec().
    */
    if (cap_set_flag(capabilities, CAP_PERMITTED, sizeof root_caps / sizeof root_caps[0], root_caps, CAP_SET) ||
        cap_set_flag(capabilities, CAP_EFFECTIVE, sizeof root_caps / sizeof root_caps[0], root_caps, CAP_SET)) {
        fprintf(stderr, "Cannot manipulate capability data structure as root: %s.\n", strerror(errno));
        return 1;
    }

    /* Above, we just manipulated the data structure describing the flags,
     * not the capabilities themselves. So, set those capabilities now. */
    if (cap_set_proc(capabilities)) {
        fprintf(stderr, "Cannot set capabilities as root: %s.\n", strerror(errno));
        return 1;
    }

    /* We wish to retain the capabilities across the identity change,
     * so we need to tell the kernel. */
    if (prctl(PR_SET_KEEPCAPS, 1L)) {
        fprintf(stderr, "Cannot keep capabilities after dropping privileges: %s.\n", strerror(errno));
        return 1;
    }

    /* Drop extra privileges (aside from capabilities) by switching
     * to the original real user. */
    if (setresuid(user, user, user)) {
        fprintf(stderr, "Cannot drop root privileges: %s.\n", strerror(errno));
        return 1;
    }

    /* We can still switch to a different user due to having the CAP_SETUID
     * capability. Let's clear the capability set, except for the CAP_SYS_NICE
     * in the permitted and effective sets. */
    if (cap_clear(capabilities)) {
        fprintf(stderr, "Cannot clear capability data structure: %s.\n", strerror(errno));
        return 1;
    }
    if (cap_set_flag(capabilities, CAP_PERMITTED, sizeof user_caps / sizeof user_caps[0], user_caps, CAP_SET) ||
        cap_set_flag(capabilities, CAP_EFFECTIVE, sizeof user_caps / sizeof user_caps[0], user_caps, CAP_SET)) {
        fprintf(stderr, "Cannot manipulate capability data structure as user: %s.\n", strerror(errno));
        return 1;
    }

    /* Apply modified capabilities. */
    if (cap_set_proc(capabilities)) {
        fprintf(stderr, "Cannot set capabilities as user: %s.\n", strerror(errno));
        return 1;
    }

    /*
     * Now we have just the normal user privileges,
     * plus user_caps.
    */

    test_priority("SCHED_OTHER", SCHED_OTHER);
    test_priority("SCHED_BATCH", SCHED_BATCH);
    test_priority("SCHED_IDLE", SCHED_IDLE);
    test_priority("SCHED_FIFO", SCHED_FIFO);
    test_priority("SCHED_RR", SCHED_RR);

    return 0;
}

请注意，如果您知道二进制文件仅在相对较新的 Linux 内核上运行，则可以依赖文件功能。然后，您main()不需要任何身份或能力操作——您可以删除main()除test_priority()函数之外的所有内容——并且您只需为二进制文件赋予./testprioCAP_SYS_NICE 优先级：

sudo setcap 'cap_sys_nice=pe' ./testprio

您可以运行getcap以查看在执行二进制文件时授予了哪些优先级：

getcap ./testprio

应该显示

./testprio = cap_sys_nice+ep

到目前为止，文件功能似乎很少使用。在我自己的系统上，gnome-keyring-daemon是唯一具有文件功能的系统（CAP_IPC_LOCK，用于锁定内存）。

于 2012-11-01T21:51:16.753 回答
1

我有一些代码在我的应用程序的主线程中接近启动时运行：

您必须在要使用它们的每个线程中获取这些功能，或者使用CAP_INHERITABLE集合。

从功能（7）：

Linux 将传统上与超级用户相关的权限划分为不同的单元，称为功能，可以独立启用和禁用。 功能是每个线程的属性。

于 2012-11-01T19:17:33.560 回答