1
$ ls -l /etc/shadow
2
-rw-r----- 1 root shadow 1234 Apr 19 10:00 /etc/shadow

1
// include/linux/cred.h — 进程凭证结构体（简化）
2
struct cred {
3
    kuid_t uid;         /* 真实 UID */
4
    kgid_t gid;         /* 真实 GID */
5
    kuid_t euid;        /* 有效 UID */
6
    kgid_t egid;        /* 有效 GID */
7
    kuid_t suid;        /* 保存的 set-user-ID */
8
    kgid_t sgid;        /* 保存的 set-group-ID */
9
    kuid_t fsuid;       /* 文件系统 UID（通常 = euid） */
10
    kgid_t fsgid;       /* 文件系统 GID（通常 = egid） */
11
    // ... Capabilities、安全上下文等
12
};

1
$ ls -l /usr/bin/passwd
2
-rwsr-xr-x 1 root root 68208 Apr 19 10:00 /usr/bin/passwd

1
// include/linux/cred.h — cred 中的 Capabilities 字段
2
struct cred {
3
    // ... uid/gid 等
4
    kernel_cap_t cap_inheritable;  /* 可继承的 Capabilities */
5
    kernel_cap_t cap_permitted;    /* 允许使用的 Capabilities */
6
    kernel_cap_t cap_effective;    /* 当前生效的 Capabilities */
7
    kernel_cap_t cap_bounding;     /* Bounding 集合（上限） */
8
    kernel_cap_t cap_ambient;      /* 环境Capabilities（非setuid时继承） */
9
    // ...
10
};

1
# 给 nginx 赋予绑定特权端口的 Capability，而无需 root
2
$ sudo setcap cap_net_bind_service=+ep /usr/sbin/nginx
3

4
# 查看文件的 Capabilities
5
$ getcap /usr/sbin/nginx
6
/usr/sbin/nginx = cap_net_bind_service+ep
7

8
# 移除文件的 Capabilities
9
$ sudo setcap -r /usr/sbin/nginx

1
# 查看当前进程的 Capabilities
2
$ capsh --print
3
Current: = cap_chown,cap_dac_override,...+eip
4
Bounding set =cap_chown,cap_dac_override,...
5

6
# 以特定 Capability 启动进程
7
$ capsh --caps="cap_net_bind_service+ep" -- -c "./myserver"
8

9
# 降权：移除所有 Capabilities 后运行
10
$ capsh --drop=all -- -c "id"
11
uid=0(root) gid=0(root) groups=0(root)  # UID 仍是 root
12
# 但没有任何 Capability，很多特权操作会被拒绝

1
// kernel/capability.c — 系统调用实现
2

3
// 获取进程 Capabilities
4
SYSCALL_DEFINE2(capget, cap_user_header_t, header, cap_user_data_t, dataptr)
5
{
6
    struct __user_cap_header_struct cap_header;
7
    // ... 从 current->cred 中读取各集合
8
}
9

10
// 设置进程 Capabilities
11
SYSCALL_DEFINE2(capset, cap_user_header_t, header, const cap_user_data_t, data)
12
{
13
    // ... 权限检查：新集合不能超出 Permitted 和 Bounding
14
    // ... 提交新的 cred
15
}
16

17
// 权限检查：进程是否拥有指定 Capability
18
bool has_capability(struct task_struct *t, int cap)
19
{
20
    return cap_raised(t->cred->cap_effective, cap);
21
}

1
// kernel/capability.c — 核心权限检查
2
bool capable(int cap)
3
{
4
    return ns_capable(&init_user_ns, cap);
5
}
6

7
bool ns_capable(struct user_namespace *ns, int cap)
8
{
9
    if (unlikely(!cap_valid(cap))) return false;
10
    if (security_capable(ns, current_cred(), cap) == 0) {
11
        // LSM 钩子也通过后，标记已使用（用于审计）
12
        current->flags |= PF_SUPERPRIV;
13
        return true;
14
    }
15
    return false;
16
}

1
// include/linux/cred.h — 完整的 cred 结构体（关键字段）
2
struct cred {
3
    atomic_t    usage;              /* 引用计数 */
4
    kuid_t      uid;                /* 真实 UID */
5
    kgid_t      gid;                /* 真实 GID */
6
    kuid_t      euid;               /* 有效 UID */
7
    kgid_t      egid;               /* 有效 GID */
8
    kuid_t      suid;               /* 保存的 set-user-ID */
9
    kgid_t      sgid;               /* 保存的 set-group-ID */
10
    kuid_t      fsuid;              /* 文件系统 UID */
11
    kgid_t      fsgid;              /* 文件系统 GID */
12
    unsigned    securebits;         /* SUID 相关安全位 */
13
    kernel_cap_t cap_inheritable;   /* 可继承 Capabilities */
14
    kernel_cap_t cap_permitted;     /* 允许 Capabilities */
15
    kernel_cap_t cap_effective;     /* 生效 Capabilities */
16
    kernel_cap_t cap_bounding;      /* Bounding 集合 */
17
    kernel_cap_t cap_ambient;       /* 环境 Capabilities */
18
    unsigned char jit_keyring;      /* JIT 密钥环 */
19
    struct key  *session_keyring;   /* 会话密钥环 */
20
    struct key  *process_keyring;   /* 进程密钥环 */
21
    struct key  *thread_keyring;    /* 线程密钥环 */
22
    struct key  *request_key_auth;  /* 密钥授权 */
23
    void        *security;          /* LSM 安全上下文 */
24
    struct user_struct *user;       /* 用户资源统计 */
25
    struct user_namespace *user_ns; /* 用户命名空间 */
26
    struct group_info *group_info;  /* 补充组信息 */
27
    struct rcu_head rcu;            /* RCU 回收 */
28
};

1
// kernel/cred.c — 准备新的凭证
2
struct cred *prepare_creds(void)
3
{
4
    struct task_struct *task = current;
5
    const struct cred *old;
6
    struct cred *new;
7

8
    new = kmem_cache_alloc(cred_jar, GFP_KERNEL);
9
    if (!new) return NULL;
10

11
    old = task->cred;
12
    memcpy(new, old, sizeof(struct cred));  // 复制旧凭证
13

14
    atomic_set(&new->usage, 1);
15
    // ... 初始化引用计数、RCU 等
16
    return new;
17
}
18

19
// 提交新凭证
20
int commit_creds(struct cred *new)
21
{
22
    struct task_struct *task = current;
23
    const struct cred *old = task->cred;
24

25
    // ... 各种合法性检查
26
    rcu_assign_pointer(task->cred, new);  // RCU 原子替换
27
    put_cred(old);                         // 释放旧凭证
28
    return 0;
29
}

1
// include/linux/lsm_hook_defs.h — 部分 LSM 钩子定义
2
LSM_HOOK(int, 0, inode_permission, struct inode *inode, int mask)
3
LSM_HOOK(int, 0, file_open, struct file *file)
4
LSM_HOOK(int, 0, task_create, unsigned long clone_flags)
5
LSM_HOOK(int, 0, task_kill, struct task_struct *p, int signum)
6
LSM_HOOK(int, 0, sb_mount, const char *dev_name, struct path *path, ...)
7
LSM_HOOK(int, 0, capget, struct task_struct *target, ...)
8
// ... 约 200+ 个钩子

1
$ cat /sys/kernel/security/lsm
2
lockdown,capability,yama,selinux,bpf

1
# 查看文件的安全上下文
2
$ ls -Z /var/www/html/index.html
3
system_u:object_r:httpd_sys_content_t:s0 /var/www/html/index.html
4

5
# 查看进程的安全上下文
6
$ ps -Z -C nginx
7
system_u:system_r:httpd_t:s0    1234 ?  00:00:00 nginx

1
# 允许 httpd_t 域读取 httpd_sys_content_t 类型的文件
2
allow httpd_t httpd_sys_content_t:file { read getattr open };
3

4
# 允许 httpd_t 域连接 TCP 套接字
5
allow httpd_t httpd_port_t:tcp_socket { name_connect };

1
// security/selinux/avc.c — AVC 查询
2
int avc_has_perm(u32 ssid, u32 tsid, u16 tclass, u32 requested,
3
                 struct common_audit_data *auditdata)
4
{
5
    struct avc_node *node;
6
    // 1. 先查 AVC 缓存
7
    node = avc_lookup(ssid, tsid, tclass);
8
    if (node) {
9
        // 缓存命中，直接返回
10
        if (node->ae.avd.allowed & requested)
11
            return 0;  // 允许
12
    }
13
    // 2. 缓存未命中，查询安全服务器（SS）
14
    rc = security_compute_av(ssid, tsid, tclass, &avd);
15
    // 3. 将结果插入 AVC 缓存
16
    avc_insert(ssid, tsid, tclass, &avd);
17
    return rc;
18
}

1
$ avcstat
2
lookups     hits    misses    allocations  reclaims    frees
3
87654321 87654000       321          321          0        0

1
# 查看当前模式
2
$ sestatus
3
SELinux status:                 enabled
4
SELinux mode:                   Enforcing
5

6
# 临时切换到 Permissive 模式（重启后恢复）
7
$ sudo setenforce 0
8

9
# 永久修改模式（修改 /etc/selinux/config）
10
$ sudo sed -i 's/SELINUX=enforcing/SELINUX=permissive/' /etc/selinux/config

1
security/selinux/
2
├── avc.c           # 访问向量缓存
3
├── hooks.c         # LSM 钩子实现（2000+ 行）
4
├── ss/             # 安全服务器（策略引擎）
5
│   ├── policydb.c  # 策略数据库
6
│   ├── services.c  # 策略查询服务
7
│   ├── sidtab.c    # SID 表
8
│   └── ebitmap.c   # 扩展位图
9
├── selinuxfs.c     # /sys/fs/selinux 文件系统
10
├── xfrm.c          # 网络安全关联
11
└── netlabel.c      # 网络标签

1
# 查看 AppArmor 状态
2
$ sudo aa-status
3
apparmor module is loaded.
4
14 profiles are loaded.
5
14 profiles are in enforce mode.
6
0 profiles are in complain mode.
7

8
# 生成新 profile（学习模式）
9
$ sudo aa-genprof /usr/sbin/mysqld
10

11
# 将 profile 设为 complain 模式（仅记录不拒绝）
12
$ sudo aa-complain /usr/sbin/nginx
13

14
# 将 profile 设为 enforce 模式
15
$ sudo aa-enforce /usr/sbin/nginx

1
// 示例：只允许 read, write, exit, sigreturn，拒绝其他
2
#include <linux/seccomp.h>
3
#include <linux/filter.h>
4
#include <linux/audit.h>
5

6
struct sock_filter filter[] = {
7
    /* 加载系统调用号 */
8
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
9
    /* 允许 read */
10
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_read, 0, 1),
11
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
12
    /* 允许 write */
13
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 0, 1),
14
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
15
    /* 允许 exit */
16
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_exit, 0, 1),
17
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
18
    /* 允许 exit_group */
19
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_exit_group, 0, 1),
20
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
21
    /* 其他系统调用返回 ERRNO(EPERM) */
22
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | EPERM),
23
};

1
// kernel/seccomp.c — 系统调用入口检查
2
int __secure_computing(const struct seccomp_data *sd)
3
{
4
    int mode = current->seccomp.mode;
5
    int data;
6

7
    switch (mode) {
8
    case SECCOMP_MODE_STRICT:
9
        // 严格模式：只允许 4 个系统调用
10
        return __seccomp_mode_strict(sd);
11
    case SECCOMP_MODE_FILTER:
12
        // BPF 过滤模式：执行 BPF 程序
13
        return __seccomp_mode_filter(sd);
14
    default:
15
        BUG();
16
    }
17
}
18

19
// BPF 过滤模式
20
static int __seccomp_mode_filter(const struct seccomp_data *sd)
21
{
22
    struct seccomp_filter *f;
23
    u32 ret;
24

25
    // 遍历所有已安装的过滤器（支持多层叠加）
26
    for (f = current->seccomp.filter; f; f = f->prev) {
27
        // 执行 BPF 程序
28
        ret = bpf_prog_run_pin_on_cpu(f->prog, sd);
29
        // 根据返回动作处理
30
        switch (ret & SECCOMP_RET_ACTION_FULL) {
31
        case SECCOMP_RET_ALLOW:
32
            return 0;
33
        case SECCOMP_RET_KILL_PROCESS:
34
            do_exit(SIGKILL);
35
        case SECCOMP_RET_ERRNO:
36
            return -(int)(ret & SECCOMP_RET_DATA);
37
        // ... 其他动作
38
        }
39
    }
40
    return 0;
41
}

1
// Docker 默认 Seccomp profile 片段（禁止的危险系统调用）
2
{
3
  "defaultAction": "SCMP_ACT_ERRNO",
4
  "architectures": ["SCMP_ARCH_X86_64"],
5
  "syscalls": [
6
    { "names": ["read", "write", "open", "close", "..."], "action": "SCMP_ACT_ALLOW" },
7
    { "names": ["mount", "umount2", "ptrace", "kexec_load", "..."], "action": "SCMP_ACT_KILL" }
8
  ]
9
}

1
#include <seccomp.h>
2

3
int main() {
4
    scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);  // 默认拒绝
5

6
    // 允许特定系统调用
7
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
8
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
9
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
10

11
    // 允许 open 但限制参数
12
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(open), 1,
13
        SCMP_A1(SCMP_CMP_EQ, O_RDONLY));  // 只允许只读打开
14

15
    // 加载过滤器（不可逆！）
16
    seccomp_load(ctx);
17
    seccomp_release(ctx);
18

19
    // 此后只能调用 read/write/exit 和只读 open
20
}

1
# 查看 Audit 状态
2
$ sudo auditctl -s
3
enabled 1
4
failure 1
5
pid 1234
6
rate_limit 0
7
backlog_limit 8192
8
lost 0
9
backlog 0
10

11
# 添加文件监控规则
12
$ sudo auditctl -w /etc/shadow -p wa -k shadow_changes
13
# -w: 监控路径  -p: 权限(w=写,a=属性修改)  -k: 规则标签
14

15
# 添加系统调用监控规则
16
$ sudo auditctl -a always,exit -F arch=b64 -S mount -S umount2 -k mount_ops
17

18
# 搜索审计日志
19
$ sudo ausearch -k shadow_changes
20
----
21
type=SYSCALL msg=audit(1713513600.123:456): arch=c000003e syscall=2 success=yes exit=3
22
  a0=7ffd1234 a1=241 a2=1b6 a3=0 items=1 ppid=1234 pid=5678
23
  auid=1000 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0
24
  tty=pts0 ses=1 comm="vim" exe="/usr/bin/vim"
25
  key="shadow_changes"
26

27
# 生成审计报告
28
$ sudo aureport --summary

1
# Kubernetes Pod 安全上下文示例
2
apiVersion: v1
3
kind: Pod
4
spec:
5
  securityContext:
6
    runAsNonRoot: true        # 禁止 root 运行
7
    runAsUser: 1000           # 指定 UID
8
    fsGroup: 2000             # 文件系统 GID
9
    seccompProfile:
10
      type: RuntimeDefault    # 使用容器运行时的默认 Seccomp profile
11
  containers:
12
  - name: app
13
    securityContext:
14
      allowPrivilegeEscalation: false  # 禁止 setuid 提权
15
      readOnlyRootFilesystem: true     # 只读根文件系统
16
      capabilities:
17
        drop: ["ALL"]                  # 移除所有 Capabilities
18
        add: ["NET_BIND_SERVICE"]      # 仅添加需要的 Capability

1
# 1. 查看当前 shell 的 Capabilities
2
$ capsh --print
3

4
# 2. 查看系统文件的 Capabilities
5
$ getcap -r /usr/bin/ 2>/dev/null
6
/usr/bin/ping = cap_net_raw+ep
7
/usr/bin/newuidmap = cap_setuid+ep
8
/usr/bin/newgidmap = cap_setgid+ep
9

10
# 3. 给文件设置 Capability
11
$ sudo setcap cap_net_bind_service=+ep ./myserver
12
$ getcap ./myserver
13
./myserver = cap_net_bind_service+ep
14

15
# 4. 以受限 Capability 运行命令
16
$ capsh --drop=all -- -c "cat /etc/shadow"
17
cat: /etc/shadow: Permission denied
18
# 即使是 root，没有 CAP_DAC_OVERRIDE 也无法读取
19

20
# 5. 查看进程的 Capabilities（通过 /proc）
21
$ cat /proc/$$/status | grep Cap
22
CapInh: 0000000000000000
23
CapPrm: 0000003fffffffff
24
CapEff: 0000003fffffffff
25
CapBnd: 0000003fffffffff
26
CapAmb: 0000000000000000
27

28
# 解码 Capability 位图
29
$ capsh --decode=0000003fffffffff
30
0x0000003fffffffff=cap_chown,cap_dac_override,cap_dac_read_search,...

1
# 1. 查看 SELinux 状态
2
$ sestatus
3
SELinux status:                 enabled
4
SELinux mount:                  /sys/fs/selinux
5
SELinux root directory:         /etc/selinux
6
Loaded policy name:             targeted
7
Current mode:                   enforcing
8
Mode from config file:          enforcing
9
Policy MLS status:              enabled
10
Policy deny_unknown status:     allowed
11
Memory protection checking:     actual (secure)
12
Max kernel policy version:      33
13

14
# 2. 查看文件和进程的安全上下文
15
$ ls -Z /var/www/html/
16
$ ps -Z -C httpd
17

18
# 3. 查看 SELinux 拒绝日志
19
$ sudo ausearch -m avc -ts recent
20
# 或使用 sealert 获取可读解释
21
$ sudo sealert -a /var/log/audit/audit.log
22

23
# 4. 临时切换到 Permissive 模式
24
$ sudo setenforce 0
25
$ getenforce
26
Permissive
27

28
# 5. 恢复 Enforcing 模式
29
$ sudo setenforce 1

1
# 1. 查看进程的 Seccomp 状态
2
$ cat /proc/$$/status | grep Seccomp
3
Seccomp: 0    # 0=禁用, 1=严格, 2=过滤
4

5
# 2. 查看 Docker 容器的 Seccomp profile
6
$ docker inspect --format='{{.HostConfig.SecurityOpt}}' mycontainer
7

8
# 3. 使用 strace 验证 Seccomp 过滤
9
$ docker run --rm -it alpine sh -c "strace -e mount mount /dev/sda1 /mnt"
10
# 应该看到 mount 被拒绝（EPERM 或 SIGSYS）
11

12
# 4. 使用 libseccomp 的 scmp_bpf_sim 工具测试规则
13
$ scmp_bpf_sim -a x86_64 -s openat -a 0 <<< 'allow if syscall == read'

1
# 1. 查看 Audit 状态
2
$ sudo auditctl -s
3

4
# 2. 添加监控规则
5
$ sudo auditctl -w /etc/passwd -p wa -k passwd_changes
6

7
# 3. 触发审计事件
8
$ sudo chmod 644 /etc/passwd
9

10
# 4. 搜索审计日志
11
$ sudo ausearch -k passwd_changes | head -20
12

13
# 5. 生成审计报告
14
$ sudo aureport -x --summary    # 按可执行文件汇总
15
$ sudo aureport -f --summary    # 按文件汇总
16
$ sudo aureport -u --summary    # 按用户汇总
17

18
# 6. 删除监控规则
19
$ sudo auditctl -W /etc/passwd -p wa -k passwd_changes

1
# 1. 查看 AppArmor 状态
2
$ sudo aa-status
3

4
# 2. 查看进程的 AppArmor profile
5
$ cat /proc/$$/attr/current
6
unconfined    # 未被限制
7

8
# 3. 列出所有已加载的 profile
9
$ sudo aa-status --profiles
10

11
# 4. 查看特定 profile 的详情
12
$ sudo aa-status --profile /usr/sbin/nginx

1
# 1. 创建一个只能绑定特权端口的受限进程
2
$ sudo setcap cap_net_bind_service=+ep ./webserver
3
$ ./webserver  # 可以绑定 80 端口，但无其他特权
4

5
# 2. 验证它无法执行其他特权操作
6
$ sudo setcap cap_net_bind_service=+ep ./webserver
7
$ ./webserver &
8
$ cat /proc/$(pgrep webserver)/status | grep Cap
9
# 只有 cap_net_bind_service 被设置
10

11
# 3. 使用 strace 观察权限检查
12
$ strace -e trace=open,openat ./webserver 2>&1 | head