linux capability详解与容器中的capability

最新推荐文章于 2024-01-09 13:51:32 发布
最新推荐文章于 2024-01-09 13:51:32 发布
阅读量4.6k 收藏 8
点赞数 3
分类专栏： docker Linux 文章标签： linux 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42152531/article/details/120543324
版权

linux capability详解

一、capability概述

在许多文章中都有讲到这部分，本文不做过多解释。自行百度。

capabilities(7) — Linux manual page——官方权威！！！
Linux Capabilities 入门教程：概念篇——米开朗基杨
Linux Capabilities 入门教程：基础实战篇——米开朗基杨
Linux Capabilities 入门教程：进阶实战篇——米开朗基杨
Linux capability详解——弥敦道人-CSDN

在Linux内核2.2之前，为了检查进程权限，将进程区分为两类：特权进程(euid=0)和非特权进程。特权进程(通常为带有suid的程序)可以获取完整的root权限来对系统进行操作。

在linux内核2.2之后引入了capabilities机制，来对root权限进行更加细粒度的划分。如果进程不是特权进程，而且也没有root的有效id，系统就会去检查进程的capabilities，来确认该进程是否有执行特权操作的的权限。

可以通过man capabilities来查看具体的capabilities。

linux一共由5种权限集合。

Permitted ——可以赋予别人的权限。在下文中用大写P简称该权限
Effective ——当前有限的权限（真正实行权限的东西）。在下文中用大写E简称该权限
Inheritable ——可继承的权限。在下文中用大写I简称该权限
Bounding ——边界权限。在下文中用大写B简称该权限
Ambient——环境权限。在下文中用大写A简称该权限

1.1 查看当前用户的权限

查看/proc/$$/status文件中的Cap部分

普通用户

ubuntu@ubuntu-standard-pc:~$ cat /proc/$$/status | grep Cap
CapInh:	0000000000000000
CapPrm:	0000000000000000
CapEff:	0000000000000000
CapBnd:	000001ffffffffff
CapAmb:	0000000000000000

root用户

root@ubuntu-standard-pc:~# cat /proc/$$/status | grep Cap
CapInh:	0000000000000000
CapPrm:	000001ffffffffff
CapEff:	000001ffffffffff
CapBnd:	000001ffffffffff
CapAmb:	0000000000000000

CapInh对应上文的I
CapPrm对应上文的P
CapEff对应上文的E
CapBnd对应上文的B
CapAmb对应上文的A

1.2 进程的权限

下文中的进程权限用pP、pI、pE、pB、pA来分别对应进程的P、I、E、B、A

首先创建一个进程，sleep进程。sleep 100秒。并且在后台运行。（末尾 &表示后台运行）

ubuntu@ubuntu-standard-pc:~$ sleep 100 &
[1] 1968

可以看到该进程的pid为1968，查看该进程的状态，（位置在/proc/"pid"/status）抓取capability部分。
/proc/pid号/status中记录了该pid进程的状态，包括了该进程的权限（capability）

如果不知道进程号，可以使用ps -ef命令来输出所有的进程，然后通过grep命令来搜索想要的信息。
例如本例子中，则可以

ubuntu@ubuntu-standard-pc:~$ ps -ef | head -1; ps -ef | grep sleep
UID        PID  PPID  C STIME TTY          TIME CMD
root      1595  1638  0 10:35 ?        00:00:00 sleep 60
1030775+  1968  1896  0 10:35 pts/1    00:00:00 sleep 100
1030775+  2065 59302  0 10:35 ?        00:00:00 sleep 5
1030775+  2175  1896  0 10:35 pts/1    00:00:00 grep --color=auto sleep

head -1的意思是输出表头，就是UID PID PPID C STIME TTY TIME CMD那一行。

ubuntu@ubuntu-standard-pc:~$ cat /proc/1968/status | grep Cap
CapInh: 0000000000000000
CapPrm: 0000000000000000
CapEff: 0000000000000000
CapBnd: 0000003fffffffff
CapAmb: 0000000000000000

可以看到，该进程的只有B有权限，其他所有集合均没有权限。与该用户的权限是一致的。至于为什么，下文会说。（不是简单的全部复制过来哦~）

我们继续看root用户的。

ubuntu@ubuntu-standard-pc:~$ sudo -i
root@ubuntu-standard-pc:~# cat /proc/$$/status | grep Cap
CapInh:	0000000000000000
CapPrm:	000001ffffffffff
CapEff:	000001ffffffffff
CapBnd:	000001ffffffffff
CapAmb:	0000000000000000

可以看到root用户的权限，只有I和A没有，其他权限都有。与root用户本身的权限是一致的。至于为什么，下文会说。（同样不是简单的全部复制过来哦~）

1.3 在进程内部进行用户切换（进程内调用setuid和setgid）

当一个进程在执行过程中发生用户切换的时候（在进程的执行代码中，调用了系统调用setuid和setgid）那么进程的capability也会发生相应的变化。
内核代码阅读——一定要收藏啊啊啊！！！

在内核中处理这部分的代码如下：

内核代码位置/security/commoncap.c：1087行

static inline void cap_emulate_setxuid(struct cred *new, const struct cred *old)
{
	kuid_t root_uid = make_kuid(old->user_ns, 0);

	if ((uid_eq(old->uid, root_uid) ||
	     uid_eq(old->euid, root_uid) ||
	     uid_eq(old->suid, root_uid)) 				//这3个，表示进程原来的用户是root用户
	     &&
	    (!uid_eq(new->uid, root_uid) &&
	     !uid_eq(new->euid, root_uid) &&
	     !uid_eq(new->suid, root_uid))) 			//这3个，表示进程限制的用户不是root用户
	     {
		if (!issecure(SECURE_KEEP_CAPS)) {			//如果没有设置KEEP_CAPS标志，则清除P和E权限集合
			cap_clear(new->cap_permitted);
			cap_clear(new->cap_effective);
		}

		/*
		 * Pre-ambient programs expect setresuid to nonroot followed
		 * by exec to drop capabilities.  We should make sure that
		 * this remains the case.
		 */
		cap_clear(new->cap_ambient);				//不管是不是root，统统清除A
	}
	if (uid_eq(old->euid, root_uid) && !uid_eq(new->euid, root_uid))
		cap_clear(new->cap_effective);				//曾经是root，现在切换成非root，则清除E
	if (!uid_eq(old->euid, root_uid) && uid_eq(new->euid, root_uid))
		new->cap_effective = new->cap_permitted;	//曾经是非root，现在切换成root，则E=P
}

上述内核代码主要的功能总结如下：

进程以前是root，切换成非root用户以后。如果没有设置KEEP_CAPS标志，则清除E和P权限集。
如果设置了KEEP_CAPS标志，则保留P权限集。

总而言之，只要发生了从root到普通用户切换，E的权限都会被清除掉，P的权限则视是否设置了KKEP_CAPS标志情况而定。

1.3.1 测试内核代码

本文例子中使用golang编程语言。

代码文件名：setid.go

package main

import (
	"fmt"
	"syscall"
	"time"
)

//SetKeepCaps 表示设置保留权限(capability)标志
func SetKeepCaps() error {
	if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_KEEPCAPS, 1, 0); err != 0 {
		return err
	}

	return nil
}

//ClearKeepCaps 表示设置不保留权限(capability)标志
func ClearKeepCaps() error {
	if _, _, err := syscall.RawSyscall(syscall.SYS_PRCTL, syscall.PR_SET_KEEPCAPS, 0, 0); err != 0 {
		return err
	}

	return nil
}

func main() {

	fmt.Println("Hello world!")
	fmt.Println("before set, the uid is ", syscall.Getuid())
	fmt.Println("before set, the gid is ", syscall.Getgid())
	fmt.Println("before set, the effective uid is ", syscall.Geteuid())

	fmt.Println("|***********************************|")

	if err := SetKeepCaps(); err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println("*     secessfully set keep caps     *")
	}
	fmt.Println("|***********************************|")

	syscall.Setgid(1000)
	syscall.Setuid(1000)
	//syscall.Setgid(0)
	//syscall.Setuid(0)
	fmt.Println("after set, the uid is ", syscall.Getuid())
	fmt.Println("after set, the gid is ", syscall.Getgid())
	fmt.Println("after set, the effective uid is ", syscall.Geteuid())

	// if err := ClearKeepCaps(); err != nil {
	// 	return
	// }
	// fmt.Println("after Clear, the uid is ", syscall.Getuid())
	// fmt.Println("after Clear, the gid is ", syscall.Getgid())
	time.Sleep(100 * time.Second)
}

上述代码实现的功能：

  1. 首先，设置KEEP_CAPS标志
  2. 在程序内部调用setgid和setuid系统调用，完成子进程的用户切换，从root用户切换到普通用户
  3. 程序休眠100s，在这个时间内，可以用ps命令查找该程序，查看该程序的权限capability

使用方法：

#bash命令
ubuntu@ubuntu-standard-pc:~/codes/go/capability$ go build setid.go

使用go build命令生成可执行文件，文件名为setid，没有后缀

然后使用root用户执行setid，这个setid可执行文件则是从root切换到1000用户上。

ubuntu@ubuntu-standard-pc:~/codes/go/capability$ sudo ./setid
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000

可以看到程序运行正常。ctrl+C退出程序，重新以后台运行的方式运行程序

ubuntu@ubuntu-standard-pc:~/codes/go/capability$ sudo ./setid &
[1] 3778
ubuntu@ubuntu-standard-pc:~/codes/go/capability$ Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000

运行以后再敲以下回车！

该程序的pid为54152，去/proc/3778/status 文件中查找权限（Cap）。

ubuntu@ubuntu-standard-pc:~/codes/go/capability$ cat /proc/3778/status | grep Cap
CapInh: 0000000000000000
CapPrm: 0000001fffffffff
CapEff: 0000000000000000
CapBnd: 0000001fffffffff
CapAmb: 0000000000000000

可以看到，该程序从root用户切换到普通用户以后，权限（capability）只有P和B，E被内核清理了。与内核代码一致。

这里的权限（capability）是进程的权限，保留的是pP和pB。

用户是否设置KEEP_CAPS切换前权限集合切换后权限集合
root->root是/否E、I、P、B、AE、I、P、B、A(不清除)
root->普通是E、I、P、B、AI、P、B(清除E、A)
root->普通否E、I、P、B、AI、B(清除E、P、A)
普通->root是/否E、I、P、B、AE、I、P、B、A(E=P)

1.4 文件权限

文件只用E、I、P权限，没有A、B权限！！！
文件只用E、I、P权限，没有A、B权限！！！
文件只用E、I、P权限，没有A、B权限！！！

1.4.1 查看某个文件的权限

下文中使用fI、fP、fE来分别表示文件的I、P、E权限

每个文件同样有权限，这些权限决定了某个用户执行该文件时可以进行哪些敏感操作。一般是看可执行文件的权限。

例如，我们的终端就是一个可执行文件，位置是/bin/bash。可以去查看该文件的权限。

ubuntu@ubuntu-standard-pc:~$ getcap /bin/bash
ubuntu@ubuntu-standard-pc:~$

可以看到该文件的权限为空。

查看我们刚刚的setid可执行文件的权限：

ubuntu@ubuntu-standard-pc:~/codes/go/capability$ getcap setid
ubuntu@ubuntu-standard-pc:~/codes/go/capability$

可以看到setid可执行文件的文件权限fI、fE、fP也为空

getcap看到的文件权限是普通用户的权限！！！
getcap看到的文件权限是普通用户的权限！！！
getcap看到的文件权限是普通用户的权限！！！
重要的事情说3遍！

对于root用户而言，系统默认为root用户设置的权限为所有权限。即fE、fI、fP均为1。这里的1是指后文进行计算时候使用的1，实际拥有哪些权限还是取决于用户root权限B（边界权限）。（cat /proc/$$/status | grep CapBnd）

root用户下的官方解释

   1. If the real or effective user ID of the process is 0 (root),
      then the file inheritable and permitted sets are ignored;
      instead they are notionally considered to be all ones (i.e.,
      all capabilities enabled).  (There is one exception to this
      behavior, described below in Set-user-ID-root programs that
      have file capabilities.)

   2. If the effective user ID of the process is 0 (root) or the
      file effective bit is in fact enabled, then the file effective
      bit is notionally defined to be one (enabled).

1.4.2 为某个文件赋权

以上文的可执行文件setid为例。setid的普通用户文件权限为空，我们来为setid赋予一点权限。

使用命令setcap来进行赋权。

root@ubuntu-standard-pc:/home/ubuntu/codes/go/capability# setcap CAP_SYS_ADMIN+eip setid
root@ubuntu-standard-pc:/home/ubuntu/codes/go/capability# getcap setid
setid = cap_sys_admin+eip

命令中的+eip(也可以用=eip)表示，在fE集合中添加cap_sys_admin权限，在fI集合中添加cap_sys_admin权限，在fP集合中添加cap_sys_admin权限

可以看到赋权成功，setid可执行文件的E、I、P权限集中都有了cap_sys_admin这个权限。

1.5 进程创建子进程的时候的权限

当我们在一个进程中创建一个子进程的时候，权限就会发生变化。

进程在进行fork()调用的时候，权限不会发生变化，子进程完全继承父进程的权限。

但是进程在进行exec()调用的时候，权限就会发生变化，具体的权限变化规则遵从以下公式：

如果子进程是root用户，则权限变化规则如下：

       p'P = pI | pB

       p'E = p'P
       p'I = pI
       p'B = pB

如果子进程是普通用户，则权限变化规则如下：

       p'A = (file is privileged) ? 0 : pA

       p'P= (pI & fI) | (fP & pB) | p'A
       
       p'E = fE ? p'P : p'A

       p'I = pI

       p'B = pB

capability在docker中

docker runc启动一个容器的过程如下：

先用root用户启动runc init进程，用户为root
然后设置pB，此时的pB已经是docker的默认capability集合了。而其他的pE、pP、pI都还是原本的capability。pA为默认的空
设置KEEP_CAPS标志。保留pP
setuid和gid。此时由root->普通用户，掉权，只剩pB、pI、pP。pE为空。
此时已经是普通用户，重新设置所有权限，pB、pI、pP、pE。此时所有权限都有。
普通用户调用系统调用exec()。掉权。实行普通用户的权限变化规则

这部分代码位置

func finalizeNamespace(config *initConfig) error {
	// Ensure that all unwanted fds we may have accidentally
	// inherited are marked close-on-exec so they stay out of the
	// container
	if err := utils.CloseExecFrom(config.PassedFilesCount + 3); err != nil {
		return err
	}

	capabilities := config.Config.Capabilities
	if config.Capabilities != nil {
		capabilities = config.Capabilities
	}
	w, err := newCapWhitelist(capabilities)
	if err != nil {
		return err
	}
	// drop capabilities in bounding set before changing user
	if err := w.dropBoundingSet(); err != nil {
		return err
	}
	// preserve existing capabilities while we change users
	if err := system.SetKeepCaps(); err != nil {
		return err
	}
	if err := setupUser(config); err != nil {
		return err
	}
	if err := system.ClearKeepCaps(); err != nil {
		return err
	}
	// drop all other capabilities
	if err := w.drop(); err != nil {
		return err
	}
	if config.Cwd != "" {
		if err := syscall.Chdir(config.Cwd); err != nil {
			return fmt.Errorf("chdir to cwd (%q) set in config.json failed: %v", config.Cwd, err)
		}
	}
	return nil
}

设置权限的代码如下：

func (c *capsV3) Set(which CapType, caps ...Cap) {
	for _, what := range caps {
		var i uint
		if what > 31 {
			i = uint(what) >> 5
			what %= 32
		}

		if which&EFFECTIVE != 0 {
			c.data[i].effective |= 1 << uint(what)
		}
		if which&PERMITTED != 0 {
			c.data[i].permitted |= 1 << uint(what)
		}
		if which&INHERITABLE != 0 {
			c.data[i].inheritable |= 1 << uint(what)
		}
		if which&BOUNDING != 0 {
			c.bounds[i] |= 1 << uint(what)
		}
	}
}

runc capability设置中，没有对权限集A进行设置，也没有对权限A进行删除。所以A一直为空。

runc顶层过程代码如下：

func (l *linuxSetnsInit) Init() error {
	if !l.config.Config.NoNewKeyring {
		// do not inherit the parent's session keyring
		if _, err := keys.JoinSessionKeyring(l.getSessionRingName()); err != nil {
			return err
		}
	}
	if l.config.NoNewPrivileges {
		if err := system.Prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0); err != nil {
			return err
		}
	}
	if l.config.Config.Seccomp != nil {
		if err := seccomp.InitSeccomp(l.config.Config.Seccomp); err != nil {
			return err
		}
	}
	if err := finalizeNamespace(l.config); err != nil {
		return err
	}
	if err := apparmor.ApplyProfile(l.config.AppArmorProfile); err != nil {
		return err
	}
	if err := label.SetProcessLabel(l.config.ProcessLabel); err != nil {
		return err
	}
	// close the statedir fd before exec because the kernel resets dumpable in the wrong order
	// https://github.com/torvalds/linux/blob/v4.9/fs/exec.c#L1290-L1318
	syscall.Close(l.stateDirFD)
	return system.Execv(l.config.Args[0], l.config.Args[0:], os.Environ())
}

调用execv以后，发生掉权。
计算过程：

       p'A = (file is privileged) ? 0 : pA

       p'P= (pI & fI) | (fP & pB) | p'A
       
       p'E = fE ? p'P : p'A

       p'I = pI

       p'B = pB

由于所有f的capability都为0，pA也为0，所以p’A=0。
p’A = 0
p’P = 0
p’E = 0
p’I = pI
p’B = pB

二、 docker 启用userns-remap

2.1 容器内部为root用户

先在主机侧创建用户

groupadd -g 10000 dockeruser
useradd -u 10000 -g dockeruser -d /home/dockeruser -m dockeruser

启用userns-remap

#vim /etc/docker/daemon.json
{
	...
	"userns-remap":"dockeruser",
	...
}

systemctl stop docker
systemctl daemon-reload
systemctl start docker

启用userns-remap以后。

Dockerfile如下：

FROM centos
ADD setid .
RUN setcap cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+eip setid

docker build

root@ubuntu-standard-pc:~# docker build -t centos:host-root-origin .

docker run

root@ubuntu-standard-pc:~# docker run -it --name centos-host-root-origin centos:host-root-origin /bin/bash

2.1.1 在容器侧的权限

[root@e72c2e81500e /]# capsh --print
Current: = cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+eip
Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap
Ambient set =
Securebits: 00/0x0/1'b0
 secure-noroot: no (unlocked)
 secure-no-suid-fixup: no (unlocked)
 secure-keep-caps: no (unlocked)
 secure-no-ambient-raise: no (unlocked)
uid=0(root)
gid=0(root)
groups=

权限与没有开启user-remap一致。且可以进入容器的root目录。

2.1.2 在主机侧的权限

查找docker进程在主机侧的pid

ubuntu@ubuntu-standard-pc:~$ ps -ef | grep e72c2e81500e
root        4253       1  0 23:12 ?        00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace moby -id e72c2e81500ec485c5664216ead98eaf5e7b7fd71b4521d4748ea6e87dbac2a3 -address /run/containerd/containerd.sock
ubuntu      4342    4334  0 23:13 pts/2    00:00:00 grep --color=auto e72c2e81500e
ubuntu@ubuntu-standard-pc:~$ ps -ef | grep 4253
root        4253       1  0 23:12 ?        00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace moby -id e72c2e81500ec485c5664216ead98eaf5e7b7fd71b4521d4748ea6e87dbac2a3 -address /run/containerd/containerd.sock
165536      4274    4253  0 23:12 pts/0    00:00:00 /bin/bash
ubuntu      4344    4334  0 23:13 pts/2    00:00:00 grep --color=auto 4253

查看主机侧docker的权限

ubuntu@ubuntu-standard-pc:~$ cat /proc/4274/status | grep Cap
CapInh:	00000000a80425fb
CapPrm:	00000000a80425fb
CapEff:	00000000a80425fb
CapBnd:	00000000a80425fb
CapAmb:	0000000000000000
ubuntu@ubuntu-standard-pc:~$ capsh --decode=00000000a80425fb
WARNING: libcap needs an update (cap=40 should have a name).
0x00000000a80425fb=cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap

可以看到，在主机侧，权限与在容器内看到的权限是一致的。

2.2 容器内部为普通用户

Dockerfile

FROM centos
ADD setid .
ADD helloworld .
ADD setid-chmod .
ADD setrootid .
RUN chmod +s setid-chmod
RUN chmod +s setrootid
RUN groupadd -g 20000 dockercentos
RUN useradd -u 20000 -g dockercentos -d /home/dockercentos -m dockercentos
USER dockercentos

docker build

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-usr# docker build -t centos:host-usr-chmod .
Sending build context to Docker daemon  7.139MB
Step 1/10 : FROM centos
 ---> 5d0da3dc9764
Step 2/10 : ADD setid .
 ---> Using cache
 ---> 01aae451ee4a
Step 3/10 : ADD helloworld .
 ---> Using cache
 ---> 91b5dc55ce84
Step 4/10 : ADD setid-chmod .
 ---> Using cache
 ---> a2b67950e1b2
Step 5/10 : ADD setrootid .
 ---> Using cache
 ---> af10aae2cff3
Step 6/10 : RUN chmod +s setid-chmod
 ---> Using cache
 ---> 62b534a30c89
Step 7/10 : RUN chmod +s setrootid
 ---> Using cache
 ---> 9afa21fd8b32
Step 8/10 : RUN groupadd -g 20000 dockercentos
 ---> Running in d233ce98d0f0
Removing intermediate container d233ce98d0f0
 ---> a29952a344b4
Step 9/10 : RUN useradd -u 20000 -g dockercentos -d /home/dockercentos -m dockercentos
 ---> Running in 9bee1a5b9ad6
Removing intermediate container 9bee1a5b9ad6
 ---> 3ccf8e7c7b7d
Step 10/10 : USER dockercentos
 ---> Running in 05feed2c8819
Removing intermediate container 05feed2c8819
 ---> 21b170f459fb
Successfully built 21b170f459fb
Successfully tagged centos:host-usr-chmod

docker run

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-usr# docker run -it --name centos-df-usr centos:host-usr-chmod /bin/bash

2.2.1 在容器侧的权限

[dockercentos@b4b1eccfcd6c /]$ capsh --print
Current: = cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+i
Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap
Ambient set =
Securebits: 00/0x0/1'b0
 secure-noroot: no (unlocked)
 secure-no-suid-fixup: no (unlocked)
 secure-keep-caps: no (unlocked)
 secure-no-ambient-raise: no (unlocked)
uid=20000(dockercentos)
gid=20000(dockercentos)
groups=

2.2.2 在主机侧的权限

ubuntu@ubuntu-standard-pc:~$ ps -ef | grep b4b1eccfcd6c
root       12587       1  0 00:57 ?        00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace moby -id b4b1eccfcd6ce1daadbe5fb6059cb9a6fea631f81eaaf0b3ae97ba839e41f64b -address /run/containerd/containerd.sock
ubuntu     12656    8418  0 00:58 pts/2    00:00:00 grep --color=auto b4b1eccfcd6c
ubuntu@ubuntu-standard-pc:~$ ps -ef | grep 12587
root       12587       1  0 00:57 ?        00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace moby -id b4b1eccfcd6ce1daadbe5fb6059cb9a6fea631f81eaaf0b3ae97ba839e41f64b -address /run/containerd/containerd.sock
185536     12609   12587  0 00:57 pts/0    00:00:00 /bin/bash
ubuntu     12658    8418  0 00:58 pts/2    00:00:00 grep --color=auto 12587

查看主机侧的权限

ubuntu@ubuntu-standard-pc:~$ cat /proc/12609/status | grep Cap
CapInh:	00000000a80425fb
CapPrm:	0000000000000000
CapEff:	0000000000000000
CapBnd:	00000000a80425fb
CapAmb:	0000000000000000

可以看到，容器内为普通用户的时候，在主机侧的权限只有I和E。

2.3 容器中的chmod

如果容器内部的某个文件，在dockerfile中设置了权限，但是容器本身没有这个权限，则无法运行该文件。
如下：

Dockerfile

FROM centos
ADD setid .
ADD helloworld .
RUN setcap cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+eip setid
RUN setcap cap_sys_admin+eip helloworld

文件helloworld拥有权限cap_sys_admin，但是容器默认权限中没有该权限。
设置的setid文件的权限=容器默认权限集。

  1. 创建docker镜像
root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root-cap# docker build -t centos:host-root-captest .
Sending build context to Docker daemon  3.562MB
Step 1/5 : FROM centos
 ---> 5d0da3dc9764
Step 2/5 : ADD setid .
 ---> Using cache
 ---> fff6dba319f3
Step 3/5 : ADD helloworld .
 ---> Using cache
 ---> e22e26214e9d
Step 4/5 : RUN setcap cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+eip setid
 ---> Running in 2094b4999f5f
Removing intermediate container 2094b4999f5f
 ---> 44ce5251d8b7
Step 5/5 : RUN setcap cap_sys_admin+eip helloworld
 ---> Running in 871c82fa3e98
Removing intermediate container 871c82fa3e98
 ---> d2bfa0175e88
Successfully built d2bfa0175e88
Successfully tagged centos:host-root-captest

运行镜像

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root-cap# docker run -it --rm centos:host-root-captest /bin/bash

[root@339688eb874d /]# ls
bin  dev  etc  helloworld  home  lib  lib64  lost+found  media	mnt  opt  proc	root  run  sbin  setid	srv  sys  tmp  usr  var
[root@339688eb874d /]# ./helloworld 
bash: ./helloworld: Operation not permitted
[root@339688eb874d /]# ./setid
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000

可以看到，helloworld文件无权限运行，setid文件有权限运行。

2.3.1 使用–cap-drop和–cap-add配合分配capabili

2.3.1.1 容器内为root用户

Dockerfile如下

FROM centos
ADD setid .
ADD helloworld .
ADD setid-chmod .
ADD setrootid .
RUN chmod +s setid-chmod
RUN chmod +s setrootid

setrootid是setid.go中，把setuid和setgid的值改为0。

docker build

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root# docker build -t centos:host-chmod .
Sending build context to Docker daemon  7.139MB
Step 1/7 : FROM centos
 ---> 5d0da3dc9764
Step 2/7 : ADD setid .
 ---> 01aae451ee4a
Step 3/7 : ADD helloworld .
 ---> 91b5dc55ce84
Step 4/7 : ADD setid-chmod .
 ---> a2b67950e1b2
Step 5/7 : ADD setrootid .
 ---> af10aae2cff3
Step 6/7 : RUN chmod +s setid-chmod
 ---> Running in 5cd11d90e4ee
Removing intermediate container 5cd11d90e4ee
 ---> 62b534a30c89
Step 7/7 : RUN chmod +s setrootid
 ---> Running in 39a322c185dd
Removing intermediate container 39a322c185dd
 ---> 9afa21fd8b32
Successfully built 9afa21fd8b32
Successfully tagged centos:host-chmod
2.3.1.1.1 不使用no-new-privileges

运行docker

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root# docker run -it --cap-drop all --cap-add={cap_setgid,cap_setuid,cap_setfcap} --rm centos:host-chmod /bin/bash
[root@07b6e17cb6d7 /]# ls
bin  etc	 home  lib64	   media  opt	root  sbin   setid-chmod  srv  tmp  var
dev  helloworld  lib   lost+found  mnt	  proc	run   setid  setrootid	  sys  usr
[root@07b6e17cb6d7 /]# ./setid
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000
^C
[root@07b6e17cb6d7 /]# ./setid-chmod 
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000
^C
[root@07b6e17cb6d7 /]# ./setrootid 
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  0
after set, the gid is  0
after set, the effective uid is  0

可以看到，可以使用setuid和setgid等。且容器内部，在seuid以前，实际的euid用户是0，root用户。

2.3.1.1.2 使用no-new-privileges

docker run

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root# docker run -it --cap-drop all --cap-add={cap_setgid,cap_setuid,cap_setfcap} --rm --security-opt=no-new-privileges centos:host-chmod /bin/bash
[root@1c3a94e2c741 /]# ls
bin  etc	 home  lib64	   media  opt	root  sbin   setid-chmod  srv  tmp  var
dev  helloworld  lib   lost+found  mnt	  proc	run   setid  setrootid	  sys  usr
[root@1c3a94e2c741 /]# ./setid
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000
^C
[root@1c3a94e2c741 /]# ./setid-chmod 
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000
^C
[root@1c3a94e2c741 /]# ./setrootid 
Hello world!
before set, the uid is  0
before set, the gid is  0
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  0
after set, the gid is  0
after set, the effective uid is  0

可以看到，与不使用no-new-privileges效果一样。euid用户依然是0(root用户)

2.3.1.2 容器内为普通用户
2.3.1.2.1 不开启no-new-privileges
root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root# docker run -it --rm --user 10000:10000 --cap-drop all --cap-add={cap_setgid,cap_setuid,cap_setfcap} centos:host-chmod /bin/bash
bash-4.4$ ./setid
Hello world!
before set, the uid is  10000
before set, the gid is  10000
before set, the effective uid is  10000
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  10000
after set, the gid is  10000
after set, the effective uid is  10000
^C
bash-4.4$ ./setid-chmod 
Hello world!
before set, the uid is  10000
before set, the gid is  10000
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  1000
after set, the gid is  1000
after set, the effective uid is  1000
^C
bash-4.4$ ./setrootid 
Hello world!
before set, the uid is  10000
before set, the gid is  10000
before set, the effective uid is  0
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  0
after set, the gid is  0
after set, the effective uid is  0

进入容器的uid和gid都指定了，且都不为root时，进入容器是完全的普通用户，setid可执行文件由于没有进行chmod提权行为，所以没有setuid和setgid的权限，无法进行setuid和setgid操作。
而setid-chmod可执行文件在dockerfile中使用了chmod +s进行提权，使得setid-chmod文件在执行的时候拥有root权限，（euid为0），所以setid-chmod文件可以进行setuid和setgid操作。该文件在容器内为root。
经过了chmod +s提权以后的文件，可以通过调用setuid和setgid，使得该文件(setrootid)可以切换为root用户。

2.3.1.2.2 开启no-new-privileges

docker run

root@ubuntu-standard-pc:/home/ubuntu/docker/Dockerfiles/centos-root# docker run -it --user 10000:10000 --cap-drop all --cap-add={cap_setgid,cap_setuid,cap_setfcap} --rm --security-opt=no-new-privileges centos:host-chmod /bin/bash
bash-4.4$ ls
bin  etc	 home  lib64	   media  opt	root  sbin   setid-chmod  srv  tmp  var
dev  helloworld  lib   lost+found  mnt	  proc	run   setid  setrootid	  sys  usr
bash-4.4$ ./setid
Hello world!
before set, the uid is  10000
before set, the gid is  10000
before set, the effective uid is  10000
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  10000
after set, the gid is  10000
after set, the effective uid is  10000
^C
bash-4.4$ ./setid-chmod 
Hello world!
before set, the uid is  10000
before set, the gid is  10000
before set, the effective uid is  10000
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  10000
after set, the gid is  10000
after set, the effective uid is  10000
^C
bash-4.4$ ./setrootid 
Hello world!
before set, the uid is  10000
before set, the gid is  10000
before set, the effective uid is  10000
|***********************************|
*     secessfully set keep caps     *
|***********************************|
after set, the uid is  10000
after set, the gid is  10000
after set, the effective uid is  10000

当开启了no-new-privileges时，无法通过chmod提权的方式，让普通用户的进程切换到root用户。
可以看到，当进入容器的uid和gid都指定了，且都不为root时，进入容器是完全的普通用户，没有setuid和setgid的权限，无法进行setuid和setgid操作。

docker run -it --name centos-host-runroot-nonewprivileges --cap-drop all --cap-add={cap_setgid,cap_setuid,cap_setfcap} --security-opt=no-new-privileges centos:host-root-origin /bin/bash

[root@LIN-29076BB8489 centos-root]# docker run -it --name centos-host-root-nonewprivileges --cap-drop all --cap-add={cap_setgid,cap_setuid,cap_setfcap} --security-opt=no-new-privileges centos:host-root-origin /bin/bash
[root@3215a191e737 /]# capsh --print
Current: = cap_setgid,cap_setuid,cap_setfcap+eip
Bounding set =cap_setgid,cap_setuid,cap_sys_admin,cap_setfcap
Ambient set =
Securebits: 00/0x0/1'b0
 secure-noroot: no (unlocked)
 secure-no-suid-fixup: no (unlocked)
 secure-keep-caps: no (unlocked)
 secure-no-ambient-raise: no (unlocked)
uid=0(root)
gid=0(root)
groups=

在主机侧查看该容器的capability

[root@LIN-29076BB8489 centos-org]# ps -ef | grep 3215a191e737
root      8080     1  0 17:11 ?        00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace moby -id 3215a191e73770dd26b393ba99acf183d0380d717da6e2c68e167f554c57a418 -address /run/containerd/containerd.sock
root      9644 58947  0 17:13 pts/1    00:00:00 grep --color=auto 3215a191e737
[root@LIN-29076BB8489 centos-org]# ps -ef | grep 8080
root      8080     1  0 17:11 ?        00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace moby -id 3215a191e73770dd26b393ba99acf183d0380d717da6e2c68e167f554c57a418 -address /run/containerd/containerd.sock
100000    8100  8080  0 17:11 pts/0    00:00:00 /bin/bash
root      9697 58947  0 17:13 pts/1    00:00:00 grep --color=auto 8080

47753则是容器主进程/bin/bash的pid。

[root@LIN-29076BB8489 centos-org]# cat /proc/8100/status | grep Cap
CapInh: 00000000800000c0
CapPrm: 00000000800000c0
CapEff: 00000000800000c0
CapBnd: 00000000800000c0
CapAmb: 0000000000000000
[root@LIN-29076BB8489 centos-org]# capsh --decode=00000000800000c0
0x00000000800000c0=cap_setgid,cap_setuid,cap_setfcap

主机侧，容器主进程只有赋予的有限权限。

三、总结

3.1 docker容器启动过程权限变化

容器内如果为普通用户，容器中的权限为
p’A = 0
p’P = 0
p’E = 0
p’I = pI
p’B = pB

3.2 限制容器的权限

限制容器权限的方法有3种。

  1. docker启用userns-remap，将docker中的root用户映射到主机上的普通用户
  2. 容器中使用普通用户，docker在启动容器的时候会进行setuid直接掉权，只剩权限集合I，在主机侧无任何权限。
  3. 使用cap-drop all 和cap-add指定权限，docker容器只拥有cap-add指定的个别权限。

启用userns-remap

#vim /etc/docker/daemon.json
{
	...	
	"userns-remap":"用户名",
	...
}

通过启用user-remap，将容器内的用户映射到主机的指定用户上，当指定的主机用户不是root用户时，容器内的root用户则映射为主机上的普通用户。

如果没有使用cap-drop，则容器拥有docker默认权限。且容器内为root用户时，有权限集合E、I、P、B。

3.2.1 启用userns-remap

是否开启userns-remap效果
是主机侧是普通用户，如果需要使用主机侧的某些权限，需要使用cap-add增加容器对应的权限，否则容器只有docker默认的权限
否主机侧是root用户，拥有root用户权限

3.2.2 限制容器内的用户

容器内的用户效果
普通用户容器内和主机侧的权限集合都只有I，如果要执行任何需要权限的操作，都需要提前在dockerfile中对对应的程序赋权
root用户容器内和主机侧的权限集合有E、I、P、B，如果需要执行需要权限的操作，只要使用cap-add对应权限即可操作，不需要在dockerfile中赋权

3.2.3 使用cap-add和cap-drop

一般使用cap-drop=all来删除docker默认的权限，然后使用cap-add添加自定义的权限。

是否使用cap-drop和cap-add效果
是容器拥有的权限只有cap-drop删掉以后，cap-add增加的指定权限，没有其他权限
否容器拥有的权限docker默认的权限
是否使用–security-opt=no-new-privileges效果
是限制容器内通过chmod提权的普通用户进程(uid != 0, euid = 0)，无法进行setuid等操作，对root用户无效
否容器内通过chmod提权的普通用户进程(uid != 0, euid = 0)，可以进行setuid等操作，将uid切换为0，可以获取root用户完整权限

4 建议

4.1 指导原则
容器拥有的权限必须>=程序的权限，否则无法运行该程序。

4.1 建议实施方案1
开启userns-remap，容器内部为root用户，使用cap-drop all cap-add={指定权限}，且设置no-new-privileges。

优点：dockerfile中不需要setcap，构建的镜像少一层。

缺点：容器内用户为root用户，在主机侧有E、I、P权限集合，可以进行某些需要权限的操作。

4.2 建议实施方案2
开启userns-remap，容器内部为普通用户，使用cap-drop all cap-add={指定权限}，在dockerfile中setcap，使用no-new-privileges

优点：容器内用户为普通用户，在主机侧只有权限I，如果容器内进程没有在dockerfile中setcap，则无法进行需要权限的操作。

缺点：需要在dockerfile中setcap。构建的镜像多一层，且无法使用提权小程序进行提权。

ImSEten
关注
专栏目录
Linux capability详解
SHELLCODE_8BIT的博客
10-12 1587
在Linux2.2前root权限简单划分为root和非root，那么root拥有全部权限，非root拥有有限的权限，如果非root用户需要安装软件，要么切换为root用户，要么使用sudo。如果我们以非root用户安装软件，会有如下提示，提示没权限。当我们使用setuid功能后，既让一个程序在运行时，能够获得root权限。如下所示非root用户成功执行apt-get安装软件。但是有没有发现，我们只需要安装功能，却在执行该进程时，拥有了root权限。可以做更多高危操作，
【云原生进阶之容器】第五章容器运行时5.3.1--runC简介与使用
junbaozi的专栏
04-01 739
随着容器技术发展的愈发火热，Linux基金会于2015年6月成立OCI（Open Container Initiative）组织，旨在围绕容器格式和运行时制定一个开放的工业化标准。该组织一成立便得到了包括谷歌、微软、亚马逊、华为等一系列云计算厂商的支持。而runC就是Docker贡献出来的，按照该开放容器格式标准（OCF, Open Container Format）制定的一种具体实现。
Linux Capabilities 基础概念与基本使用
qq_68163788的博客
01-07 1886
Linux 是一种安全的操作系统，它把所有的系统权限都赋予了一个单一的 root 用户，只给普通用户保留有限的权限。root 用户拥有超级管理员权限，可以安装软件、允许某些服务、管理用户等。 作为普通用户，如果想执行某些只有管理员才有权限的操作，以前只有两种办法： 一是通过 `sudo` 提升权限，如果用户很多，配置管理和权限控制会很麻烦； 二是通过 [SUID](https://en.wikipedia.org/wiki/Setuid)（Set User ID on execution）来实现，
Linux Capabilities利用总结
最新发布
moresec的博客
01-09 1509
Linux对于权限的管理，系统权限只有root才有，对于普通用户只有一些有限的权限；而对于普通用户如果想进行一些权限以外的操作，之前主要有两种方法：一是通过sudo提权；二是通过SUID[1]，让普通用户对设有SUID的文件具有执行权限，当用户执行此文件时，会用文件的拥有者的权限执行，比如常用的命令passwd，修改用户的密码是需要root权限的，但是普通用户却可以使用，这是因为/usr/bin/passwd被设置了SUID，该文件的拥有者是root，所以普通用户可以使用并执行。
Linux Capabilities
oneslide
06-05 2090
对于执行权限检查, 传统的UNIX实现区分两类进程:特权进程(其有效用户ID为0,也称为超级用户或root)和非特权进程(其有效用户ID非零)。特权进程绕过内核的所有权限检查,而非特权进程根据进程的凭证(通常为:有效用户ID、有效组ID和补充组列表)进行完整的权限检查。从内核2.2开始,Linux将传统上与超级用户相关联的特权分成独立的单元,称为Capability,可以独立启用和禁用。需要注意的是，功能是线程属性。
Linux Capability
09-02 906
http://stackoverflow.com/questions/7860690/using-setcap-in-linux To add the cap_net_raw capability to (for eg /bin/ping), we use the following: #setcap cap_net_raw=ep /bin/ping What is the m
linux capability
whuzm08的专栏
07-16 2422
1.目前linux支持的capability有： 2.能力的传递 子进程capabilities 获得能力的方式有两种： a.从父进程继承； b.从file capabilities，如果可执行文件设置了，和setuid和setgid原理类型，可获得比父进程更大的能力集，file capabilities保存在XATTR中； 通过fork或clone创建的子进
[转载] Linux的capability深入分析
a172742451的专栏
04-21 2742
[转载] Linux的capability深入分析 一)概述: 1)从2.1版开始,Linux内核有了能力(capability)的概念,即它打破了UNIX/LINUX操作系统中超级用户/普通用户的概念,由普通用户也可以做只有超级用户可以完成的工作. 2)capability可以作用在进程上(受限),也可以作用在程序文件上,它与sudo不同,sudo只针对用户/程序/文件的概
linux namespace的概述
dizhegccl的博客
10-23 2147
1.namespace是Linux系统的底层概念，在内核层实现，即有一些不同类型的命名空间被部署在核内，各个docker容器运行在同一个docker主进程并且共 用同一个宿主机系统内核，各docker容器运行在宿主机的用户空间，每个容器都要有类似于虚拟机一样的相互隔离的运行空间，但是容器技术是在一个 进程内实现运行指定服务的运行环境，并且还可以保护宿主机内核不受其他进程的干扰和影响，如文件系统空间、网络空间、进程空间等，目前主要通过 以下8种技术实现容器运行空间的相互隔离.
Docker容器化技术详解：构建、部署和管理容器化应用，让应用更灵活
Docker容器是一种轻量级、可移植的虚拟化技术，它允许您在隔离的环境中运行应用程序。与传统虚拟机不同，容器共享主机内核，这使得它们更加高效和轻量级。 **1.1 Docker容器的好处** * **隔离性：**容器提供应用...
【C++ 项目设计】深入JSON处理与项目实践：C++中的高效设计与应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
08-10 299
在`JSONHandler`中，我们定义了几个核心组件： - **JSON Parser (JSON 解析器)**：负责读取和解析JSON数据。 - **JSON Writer (JSON 写入器)**：负责将JSON数据写入文件或其他输出流。 - **JSON Manipulator (JSON 操作器)**：提供了一系列方法来修改、查询和操作JSON数据。 这三个组件是`JSONHandler`的基石，它们确保了数据的正确读取、写入和操作。
微服务概览与治理详解
lt_xiaodou的博客
07-29 1583
对于服务中的个别服务可能会存在有大量的其他服务都会依赖这个服务的情况，如帐号服务，那么这个时候healthcheck的检查可能会占用一定的资源，并且随着规模的增加，光healthcheck就会占用非常高的资源，如何解决这个问题呢？微服务的核心是组件化服务，通过将之前复杂的巨石机构，拆分成不同的服务，来实现组件化。这里可以理解为，对于不同的流量区别对待，对于测试的流量，也会在请求的时候带上对应的染色标记，这样到达系统的时候就会根据不同的染色标记走不同的路由，路由到具有相同染色的服务上。...
介绍-Linux capability机制
ty的专栏
03-05 5127
对Linux的capability机制进行详细介绍，并带有例子代码，说明一个普通进程如何获取某项权限。
Linux的capability深入分析（1）【转】
weixin_34167043的博客
08-15 163
转自：https://blog.csdn.net/wangpengqi/article/details/9821227 一)概述: 1)从2.1版开始,Linux内核有了能力(capability)的概念,即它打破了UNIX/LINUX操作系统中超级用户/普通用户的概念,由普通用户也可以做只有超级用户可以完成的工作. 2)capability可以作用在进程上(受限),也可以作用在...
linux中的capabilities基础概念
好好睡觉
12-11 2070
capabilities概念
Linux的capability深入分析
ConceptCon
02-25 3823
                                  Linux的capability深入分析 from:https://www.cnblogs.com/iamfy/archive/2012/09/20/2694977.html 一)概述: 1)从2.1版开始,Linux内核有了能力(capability)的概念,即它打破了UNIX/LINUX操作系统中超级用户/普通用户的概念...
Linux Capabilities 入门教程（包含自己的理解）
Jack_chao_的博客
02-15 1845
10分钟 理解 Linux Capabilities （内涵自己的见解）后续会加实战篇
linux-capabilities
weixin_45183445的博客
09-22 190
capabilities cap 为了执行权限检查，传统的UNIX实现区分两类进程：特权进程（其有效用户ID为0，称为超级用户或根用户）和非特权进程（其有效UID为非零）。特权进程绕过所有内核权限检查，而非特权进程根据进程的凭据（通常为：有效UID、有效GID和补充组列表）接受完全权限检查。 从内核2.2开始，Linux将传统上与超级用户相关的特权划分为不同的单元，称为功能，可以独立启用和禁用。功能是每个线程的属性。 使用capset系统调用设置nobody进程的线程capabilites。 ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值