capset接口作用及用法

capset 是 Linux 系统调用（syscall），用于修改进程的能力集（capabilities）。它允许更精细地控制进程的权限，替代传统的超级用户（root）全权模式，提升系统安全性。

核心作用

  1. 细粒度权限控制
    将 root 的完整权限拆分为独立的单元（如 CAP_NET_ADMIN 管理网络、CAP_SYS_TIME 修改系统时间）。进程只需获取必要的能力，无需拥有完整的 root 权限。
  2. 提升安全性
    遵循最小权限原则（Principle of Least Privilege），降低进程被滥用时的风险。
  3. 动态调整权限
    进程在运行时可以提升或降低自身/子进程的能力集。

能力集（Capabilities Sets）

每个进程关联三个能力集：

  • Permitted（允许集）：进程最大可用的能力（上限）。
  • Effective（有效集）：进程当前生效的能力（实际权限）。
  • Inheritable（可继承集）：通过 exec() 执行新程序时可保留的能力。

函数原型

1
2
3
#include <sys/capability.h>

int capset(cap_user_header_t hdrp, const cap_user_data_t datap);

参数详解

1. hdrp（能力头结构）

1
2
3
4
struct __user_cap_header_struct {
    __u32 version;  // 能力集版本（如 _LINUX_CAPABILITY_VERSION_3）
    int pid;        // 目标进程PID（0=当前进程）
};
  • version：必须指定为 _LINUX_CAPABILITY_VERSION_1/2/3（推荐使用_3）。
  • pid：0 表示修改当前进程；其他 PID 需有 CAP_SETPCAP 能力。

2. datap（能力数据）

1
2
3
4
5
struct __user_cap_data_struct {
    __u32 effective;    // 有效集
    __u32 permitted;    // 允许集
    __u32 inheritable;  // 可继承集
};
  • 每个字段是位掩码（bitmask），每一位对应一种能力（定义在 <linux/capability.h>）。

使用步骤

1. 准备头结构

1
2
3
4
struct __user_cap_header_struct hdr = {
    .version = _LINUX_CAPABILITY_VERSION_3,
    .pid = 0  // 修改当前进程
};

2. 准备能力数据

1
2
3
4
5
6
7
8
struct __user_cap_data_struct data = {0};

// 示例：添加 CAP_NET_ADMIN 到允许集和有效集
__u32 cap_mask = (1 << CAP_NET_ADMIN);  // CAP_NET_ADMIN 是能力编号

data.permitted |= cap_mask;   // 允许使用该能力
data.effective |= cap_mask;   // 立即生效
// data.inheritable = ... ;   // 按需设置可继承集

3. 调用 capset

1
2
3
4
if (capset(&hdr, &data) == -1) {
    perror("capset failed");
    exit(EXIT_FAILURE);
}

关键规则

  1. 权限限制：
    • 修改自身进程：新能力集必须是当前 Permitted 的子集。
    • 修改其他进程：需要 CAP_SETPCAP 能力。
  2. 能力继承：
    • 通过 exec() 执行新程序时，新进程的能力由 Inheritable 和可执行文件的属性共同决定。

实际应用示例

场景：赋予进程网络管理能力（无需 root）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <sys/capability.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main() {
    // 设置能力头
    struct __user_cap_header_struct hdr = {
        .version = _LINUX_CAPABILITY_VERSION_3,
        .pid = 0
    };

    // 设置能力数据：仅启用 CAP_NET_ADMIN
    struct __user_cap_data_struct data = {0};
    __u32 cap_net_admin = 1 << CAP_NET_ADMIN;
    data.permitted = cap_net_admin;   // 允许此能力
    data.effective = cap_net_admin;   // 立即生效

    // 调用 capset
    if (capset(&hdr, &data) {
        perror("Error setting capabilities");
        return 1;
    }

    // 此时进程可执行网络管理操作（如配置网卡）
    // system("ip link set eth0 up");  // 需要 CAP_NET_ADMIN
    printf("Capabilities set successfully!\n");
    return 0;
}

常见问题

  1. 权限不足：
    • 若进程无 CAP_SETPCAP 或尝试提升超出当前 Permitted 的能力，返回 EPERM。
  2. 版本不兼容：
    • 使用过时的 version 字段会导致 EINVAL。
  3. 能力未生效：
    • 确保能力已添加到 effective 集（仅 permitted 无实际权限）。

推荐工具

  • 命令行工具：
    • setcap：为可执行文件设置继承能力（如 setcap cap_net_admin+ep /path/to/bin）。
    • getcap：查看文件的能力集。
  • 开发库：
    • libcap 提供高级 API（如 cap_set_proc()），简化能力操作：
      1
      2
      3
      4
      5
      6
      7
      #include <sys/capability.h>
      cap_t caps = cap_get_proc();
      cap_value_t cap_list[] = {CAP_NET_ADMIN};
      cap_set_flag(caps, CAP_EFFECTIVE, 1, cap_list, CAP_SET);
      cap_set_flag(caps, CAP_PERMITTED, 1, cap_list, CAP_SET);
      cap_set_proc(caps);
      cap_free(caps);

总结

要点 说明
核心目的 细粒度控制进程权限，替代 root 全权模式
关键结构 cap_user_header_t（版本/PID）、cap_user_data_t（3个能力集位掩码）
修改自身进程 hdr.pid = 0，且新能力集必须是当前 Permitted 的子集
修改其他进程 需要 CAP_SETPCAP 能力
最佳实践 使用 libcap 库替代直接调用 capset

通过 capset 合理分配能力，可显著减少进程的权限攻击面，是 Linux 安全编程的重要机制。

使用capset接口修改capability权限

使用 capset 接口修改进程能力集

下面是一个完整的示例程序，展示如何使用 capset 系统调用为当前进程添加 CAP_NET_ADMIN 能力：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/syscall.h>
#include <linux/capability.h>

// 定义 capset 系统调用号
#ifndef SYS_capset
    #ifdef __x86_64__
        #define SYS_capset 126
    #elif __i386__
        #define SYS_capset 184
    #elif __aarch64__
        #define SYS_capset 90
    #else
        #error "Unsupported architecture"
    #endif
#endif

// 定义能力版本常量
#ifndef _LINUX_CAPABILITY_VERSION_3
#define _LINUX_CAPABILITY_VERSION_3  0x20080522
#endif

// 定义能力结构体
struct __user_cap_header_struct {
    __u32 version;
    int pid;
};

struct __user_cap_data_struct {
    __u32 effective;
    __u32 permitted;
    __u32 inheritable;
};

// 能力名称映射
const char *capability_names[] = {
    [CAP_CHOWN] = "CAP_CHOWN",
    [CAP_DAC_OVERRIDE] = "CAP_DAC_OVERRIDE",
    [CAP_DAC_READ_SEARCH] = "CAP_DAC_READ_SEARCH",
    [CAP_FOWNER] = "CAP_FOWNER",
    [CAP_FSETID] = "CAP_FSETID",
    [CAP_KILL] = "CAP_KILL",
    [CAP_SETGID] = "CAP_SETGID",
    [CAP_SETUID] = "CAP_SETUID",
    [CAP_SETPCAP] = "CAP_SETPCAP",
    [CAP_LINUX_IMMUTABLE] = "CAP_LINUX_IMMUTABLE",
    [CAP_NET_BIND_SERVICE] = "CAP_NET_BIND_SERVICE",
    [CAP_NET_BROADCAST] = "CAP_NET_BROADCAST",
    [CAP_NET_ADMIN] = "CAP_NET_ADMIN",
    [CAP_NET_RAW] = "CAP_NET_RAW",
    [CAP_IPC_LOCK] = "CAP_IPC_LOCK",
    [CAP_IPC_OWNER] = "CAP_IPC_OWNER",
    [CAP_SYS_MODULE] = "CAP_SYS_MODULE",
    [CAP_SYS_RAWIO] = "CAP_SYS_RAWIO",
    [CAP_SYS_CHROOT] = "CAP_SYS_CHROOT",
    [CAP_SYS_PTRACE] = "CAP_SYS_PTRACE",
    [CAP_SYS_PACCT] = "CAP_SYS_PACCT",
    [CAP_SYS_ADMIN] = "CAP_SYS_ADMIN",
    [CAP_SYS_BOOT] = "CAP_SYS_BOOT",
    [CAP_SYS_NICE] = "CAP_SYS_NICE",
    [CAP_SYS_RESOURCE] = "CAP_SYS_RESOURCE",
    [CAP_SYS_TIME] = "CAP_SYS_TIME",
    [CAP_SYS_TTY_CONFIG] = "CAP_SYS_TTY_CONFIG",
    [CAP_MKNOD] = "CAP_MKNOD",
    [CAP_LEASE] = "CAP_LEASE",
    [CAP_AUDIT_WRITE] = "CAP_AUDIT_WRITE",
    [CAP_AUDIT_CONTROL] = "CAP_AUDIT_CONTROL",
    [CAP_SETFCAP] = "CAP_SETFCAP",
    [CAP_MAC_OVERRIDE] = "CAP_MAC_OVERRIDE",
    [CAP_MAC_ADMIN] = "CAP_MAC_ADMIN",
    [CAP_SYSLOG] = "CAP_SYSLOG",
    [CAP_WAKE_ALARM] = "CAP_WAKE_ALARM",
    [CAP_BLOCK_SUSPEND] = "CAP_BLOCK_SUSPEND",
    [CAP_AUDIT_READ] = "CAP_AUDIT_READ"
};

// 打印能力集
void print_capabilities(const char *label, __u32 capset) {
    printf("%s: ", label);
    for (int i = 0; i <= CAP_LAST_CAP; i++) {
        if (capset & (1 << i)) {
            if (i < sizeof(capability_names)/sizeof(capability_names[0]) && capability_names[i]) {
                printf("%s ", capability_names[i]);
            } else {
                printf("CAP_UNKNOWN(%d) ", i);
            }
        }
    }
    printf("\n");
}

// 自定义 capset 包装函数
int my_capset(struct __user_cap_header_struct *hdrp, struct __user_cap_data_struct *datap) {
    return syscall(SYS_capset, hdrp, datap);
}

int main() {
    // 准备能力头结构
    struct __user_cap_header_struct hdr = {
        .version = _LINUX_CAPABILITY_VERSION_3,
        .pid = 0  // 0 表示当前进程
    };
    
    // 准备能力数据结构
    struct __user_cap_data_struct data = {0};
    
    // 获取当前能力集
    printf("=== 当前能力集 ===\n");
    if (my_capset(&hdr, &data) {
        perror("获取当前能力集失败");
        return 1;
    }
    
    print_capabilities("Permitted  ", data.permitted);
    print_capabilities("Effective  ", data.effective);
    print_capabilities("Inheritable", data.inheritable);
    printf("\n");
    
    // 检查是否已有 CAP_NET_ADMIN 能力
    if (data.permitted & (1 << CAP_NET_ADMIN)) {
        printf("进程已拥有 CAP_NET_ADMIN 能力\n");
    } else {
        printf("进程缺少 CAP_NET_ADMIN 能力\n");
    }
    
    // 添加 CAP_NET_ADMIN 能力
    printf("\n=== 添加 CAP_NET_ADMIN 能力 ===\n");
    
    // 设置新能力集
    __u32 cap_net_admin = (1 << CAP_NET_ADMIN);
    data.permitted |= cap_net_admin;   // 添加到允许集
    data.effective |= cap_net_admin;   // 添加到有效集
    
    // 应用新能力集
    if (my_capset(&hdr, &data)) {
        perror("capset 失败");
        printf("错误原因: %s\n", strerror(errno));
        
        if (errno == EPERM) {
            printf("\n需要 CAP_SETPCAP 能力或当前能力集的超集\n");
            printf("请尝试以 root 权限运行此程序\n");
        }
        
        return 1;
    }
    
    // 验证新能力集
    printf("\n=== 新能力集 ===\n");
    memset(&data, 0, sizeof(data)); // 重置数据结构
    if (my_capset(&hdr, &data)) {
        perror("获取新能力集失败");
        return 1;
    }
    
    print_capabilities("Permitted  ", data.permitted);
    print_capabilities("Effective  ", data.effective);
    print_capabilities("Inheritable", data.inheritable);
    
    // 检查是否成功添加
    if ((data.permitted & cap_net_admin) && (data.effective & cap_net_admin)) {
        printf("\n✅ 成功添加 CAP_NET_ADMIN 能力\n");
        printf("现在可以执行需要网络管理权限的操作\n");
    } else {
        printf("\n❌ 添加 CAP_NET_ADMIN 能力失败\n");
    }
    
    return 0;
}

程序说明

1. 关键组成部分

  • 能力头结构：指定Linux能力版本和目标进程PID
  • 能力数据结构：包含三个能力集（允许集、有效集、可继承集）
  • 能力名称映射：将能力编号转换为可读名称
  • capset系统调用：通过syscall接口直接调用

2. 功能流程

  1. 获取并显示当前进程的能力集
  2. 检查是否已拥有CAP_NET_ADMIN能力
  3. 将CAP_NET_ADMIN添加到允许集和有效集
  4. 通过capset应用新的能力集
  5. 验证新能力集是否生效

3. 使用说明

  1. 编译程序：

    1
    gcc capset_demo.c -o capset_demo

  2. 运行程序（需要root权限）：

    1
    sudo ./capset_demo

  3. 预期输出：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    === 当前能力集 ===
    Permitted  : CAP_CHOWN CAP_DAC_OVERRIDE ... 
    Effective  : CAP_CHOWN CAP_DAC_OVERRIDE ...
    Inheritable: 

    进程缺少 CAP_NET_ADMIN 能力

    === 添加 CAP_NET_ADMIN 能力 ===

    === 新能力集 ===
    Permitted  : ... CAP_NET_ADMIN ...
    Effective  : ... CAP_NET_ADMIN ...
    Inheritable: 

    ✅ 成功添加 CAP_NET_ADMIN 能力
    现在可以执行需要网络管理权限的操作

4. 注意事项

  1. 权限要求：

    • 修改能力集需要CAP_SETPCAP能力
    • 添加的能力不能超出当前允许集的范围
    • 通常需要root权限运行

  2. 能力持久性：

    • 通过capset修改的能力仅影响当前进程
    • 子进程默认不继承这些能力（除非设置inheritable集）

  3. 错误处理：

    • 程序包含详细的错误处理
    • 显示系统错误信息（如权限不足）
    • 提供解决建议

  4. 架构兼容性：

    • 支持x86_64、i386和ARM64架构
    • 自动检测系统调用号

5. 实际应用场景

  1. 网络工具：授予网络配置能力而不需要完整root权限
  2. 安全服务：以最小权限运行守护进程
  3. 容器环境：在受限环境中管理特定权限
  4. 特权操作：执行特定系统管理任务而不暴露完整root

此程序展示了Linux能力模型的核心概念，通过精细控制进程权限，遵循最小权限原则，可显著提高系统安全性。