Linux安全体系的文件权限管理

自主访问机制(Discretionary Access Control，DAC) 指对象（比如程序、文件或进程等）的的拥有者可以任意的修改或授予此对象相应的权限。Linux的UGO（User、Group、Other）和ACL（Access Control List，访问控制列表）权限管理方式就是典型的自主访问机制。

Linux支持UGO和ACL权限管理方式，UGO将权限位信息存储在节点的权限中，ACL将权限位信息存储在节点的扩展属性中。不同的文件系统权限位的存储和处理方式不一样，具体的文件系统（如：ext4）实现文件权限的管理。

本章分析了UGO和ACL权限管理方式和能力机制。

 

 

1 unix文件权限管理

传统的Unix文件系统的UGO（User、Group、Other）权限管理方式在文件和目录上设置权限位，用来控制用户或用户组对文件或目录的访问。Linux继承了Unix的UGO权限管理方式。

文件或目录文件创建时，文件系统会将文件类型、时间信息、权限信息、权限位信息存入到文件的节点中。

1.1 文件的权限位分配

一个文件创建后，它具有读、写和执行三种操作方式，UGO权限管理方式将访问文件的操作者简单地分为三类：文件属主、同组用户和其他组用户。文件属主是指创建文件的用户，他是文件的拥有者，它可以设置用户的读、写和执行权限。同组用户是指与文件属主同一个用户组的用户。

UGO权限管理方式将文件的权限用3组3位二进制位描述，还在最前面加上一位作为文件类型标识。每类用户占3位，读、写、执行权限各用1位描述，具有权限时，就将该位设置为1。读、写、执行权限分别用r、w、x三个字符表示。第一组权限位

例如：一个文件的权限列出如下：

[root@localhost /root]

^-^$ ls –l

-rw-r--r-- 1 root root 195 Jan 28 22:12 scsrun.log

最前面一位‘-’，表示文件类型为普通文件。

第一个组为"rw-"，表示文件属主具有读和写权限，但没有执行权限。

第二个组为"r--"，表示同组其他用户具有读权限，但没有写和执行权限。

第三个组为"r--"，表示其他组用户具有读权限，但没有写和执行权限。

在UGO权限管理方式中，第一个4位二进制组的第一位（最前面的一位）表示文件类型这些文件类型的描述符及含义说明如表1：

表1　文件类型的描述符

描述符	文件类型
d	目录。
l	符号链接
s	套接字文件。
b	块设备文件。
c	字符设备文件。
p	命名管道文件。
-	普通文件

例如：一个目录的权限位列出如下：

[root@localhost /root]

^-^$ ls -l

drwxr-xr-x 2 root root 4096 Jan 28 22:33 Desktop

最前面一位‘d’，表示文件类型为目录。

第一个组为"drwx"，表示文件属主具有读、写和执行权限。

第二个组为"r-x"，表示同组其他用户具有读和执行权限，但没有写权限。

第三个组为"r-x"，表示其他组用户具有读和执行权限，但没有写权限。

目录和文件的权限位是一样的，但目录与文件在权限定义上有一些区别，目录的读操作指列出目录中的内容，写操作指在目录中创建或删除文件，执行操作指搜索和访问目录。

1.2 改变权限的命令

用户缺省创建文件时，用户本身对这个文件有读写操作权限，其他用户对它具有读操作权限。用户缺省创建目录时，用户本身对目录有读、写和执行权限，同组用户有读和执行权限，其他组用户有执行权限。例如：用户创建的test文件和testdir目录的权限位列出如下：

-rw-r--r-- 1 root root 0 Feb 8 18:20 test

drwxr-xr-x 2 root root 4096 Feb 8 18:22 testdir

用户可以使用命令chmod来改变权限位，只有用户是文件的所有者或者root用户，他才能有权限改变权限位。

命令chmod有符号模式和绝对模式，符号模式指用权限位的符号形式来设置新权限位，绝对模式指直接用权限位的二进制位的数字形式设置权限位。

 

（1）chmod命令的符号模式

chmod命令的格式列出如下：

chmod [who] operator [permission] filename

who的含义列出如下：

u 文件属主权限。

g 属组用户权限。

o 其他用户权限。

a 所有用户。

operator的含义列出如下：

+ 增加权限。

- 取消权限。

= 设定权限。

permission的含义列出如下：

r 读权限。

w 写权限。

x 执行权限。

s 文件属主和组set-ID。

t 粘性位*。

l 给文件加锁，使其他用户无法访问。

u,g,o 分别表示对文件属主、同组用户及其他组用户操作。

t sticky bit，常用于共享文件，如：/tmp分区。设置t位后，同组用户即使用对文件有写操作权限，也不能删除文件。

例如：一些chomd操作命令列出如下：

chmod a-x temp 　 //删除所有用户的执行权限

chmod og-w temp //删除同组用户和其他用户的写权限

chmod g+w temp //增加同组用户写权限

chmod u+x temp //增加文件属主执行权限

chmod go+x temp //增加同组用户和其他用户执行权限

 

（2）chmod命令的绝对模式

chmod命令绝对模式的一般形式为：

chmod [mode] file

其中mode是一个八进制数，表示权限位。在绝对模式中，每一个权限位用一个八进制数来代表，权限位说明如下：

0 4 0 0 文件属主可读

0 2 0 0 文件属主可写

0 1 0 0 文件属主可执行

0 0 4 0 同组用户可读

0 0 2 0 同组用户可写

0 0 1 0 同组用户可执行

0 0 0 4 其他用户可读

0 0 0 2 其他用户可写

0 0 0 1 其他用户可执行

计算八进制权限的计算方法类似如下：

文件属主：r w x：4 + 2 + 1

同组用户：r w x：4 + 2 + 1

其他用户：r w x：4 + 2 + 1

用chmod命令绝对模式设置文件权限的样例列出如下：

chmod 666 rw- rw- rw- 　　//所有用户具有读和写的权限

chmod 644 rw- r-- r- - 　//所有文件属主具有读和写的权限，同组或其他用户具有读权限

 

1.3 suid/guid

如果属主用户对文件设置了suid权限，那么其他用户在shell执行文件时也具有其属主的相应权限。如果属主是root用户,那么其他普通用户在执行文件时也具有root用户的权限。guid有相似的机制，执行相应文件的用户将具有该文件所属用户组中用户的权限。

有些特殊情况需要使用suid/guid，例如：数据库备份时需要有系统管理权限，而系统运行的普通用户下，此时，系统管理员设置备份脚本的suid/guid，数据库备份时，备份程序通过运行备份脚本获得系统管理员权限，在备份完成后，数据库程序又恢复到普通用户的权限。

设置suid的方法是将相应的权限位之前的那一位设置为4，设置guid的方法是将相应的权限位之前的那一位设置为2，如果同时设置suid和guid，将相应的权限位之前的那一位设置为4+2。设置suid或guid需要同时设置执行权限位。

例1　设置suid

下面方法给文件test设置了suid，755表示文件属主具有读、写和执行的权限，同组用户和其他用户具有读和执行的权限。

chmod 4755 test

chmod u+s　test

设置结果为：rws r-x r-x，其中s表示设置了suid，表示其他用户在shell执行test时具有属主的权限。

例2　同时设置suid和guid

下面方法给文件test设置了suid和guid位，711表示文件属主具有读、写和执行的权限，同组用户和其他用户具有执行的权限。

chmod 6711 test

设置结果为：rws --s --s。第1个s表示设置了suid，第2个和第3个s表示设置一guid位。

 

1.4 umask

umask命令用于设置umask值，通过设置umask值，可以为新创建的文件和目录设置缺省权限。umask命令的形式如下：

umask nnn

其中nnn为umask的值，范围为000 - 777。

umask值与创建时的权限位进行"与非"逻辑运算，相当于从权限位中去掉相应的位，得到缺省的权限位。

例如，umask值为002时，创建文件和目录的缺省权限分别为664和775。因为文件创建是不能有执行权限，为666，666与002进行"与非"逻辑运算后得到664。目录创建时权限为777,777与002进行"与非"逻辑运算后得到775。

例1　设置umask值

命令umask设置umask值的方法如下：

$ umask 002

 

2 Linux能力机制

早期linux上信任状模型非常简单，就是"超级用户对普通用户"模型。普通用户的很多操作需要root权限，这通过setuid实现。如果程序编写不好，就可能被攻击者利用，获得系统的控制权。使用能力机制(capability)减小这种风险。系统管理员为了系统的安全可以剥夺root用户的能力，这样即使root用户也将无法进行某些操作。而这个过程又是不可逆的，也就是说如果一种能力被删除，除非重新启动系统，否则即使root用户也无法重新添加被删除的能力。

 

2.1 能力的定义

能力机制(capability)相关结构列出如下（在include/linux/capability.h中）：

typedef struct kernel_cap_struct {
	__u32 cap;
} kernel_cap_t;
 
typedef struct __user_cap_data_struct {
        __u32 effective;　//进程中有效的能力,是permitted的子集，允许的能力不一定有效
        __u32 permitted;　 // 进程允许使用的能力
        __u32 inheritable;// 能够被当前进程执行的程序继承的能力
} __user *cap_user_data_t;

每个进程的任务结构中有三个和能力有关的位图变量，列出如下（在include/linux/sched.h中）：

struct task_struct {
    ……
    /* 进程信任值*/
	uid_t uid,euid,suid,fsuid;
	gid_t gid,egid,sgid,fsgid;
	struct group_info *group_info;
	kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;　//能力机制
	unsigned keep_capabilities:1;　　　//表示是否保持能力值
	struct user_struct *user;
……
}

每种能力由一位表示，1表示具有某种能力，0表示没有。因而这三个能力变量最大只能表示32个能力的有否。当进程进行操作时，检查任务结构中的cap_effective的对应位是否有效，例如，如果一个进程要设置系统的时钟，Linux的内核就会检查cap_effective的CAP_SYS_TIME位(第25位)是否有效。

能力定义的宏定义列出如下（在include/linux/capability.h中）：

CAP_CHOWN 　　　　　0 　　//允许改变文件的所有权  
CAP_DAC_OVERRIDE 　 1 　 //忽略对文件的所有DAC访问限制  
CAP_DAC_READ_SEARCH 2    //忽略所有对读、搜索操作的限制  
CAP_FOWNER          3    //如果文件属于进程的UID，就取消对文件的限制  
CAP_FSETID          4    //允许设置setuid位  
CAP_KILL            5    //允许对不属于自己的进程发送信号  
CAP_SETGID          6    //允许改变组ID  
CAP_SETUID          7    //允许改变用户ID  
CAP_SETPCAP         8    //允许向其它进程转移能力以及删除其它进程的任意能力  
CAP_LINUX_IMMUTABLE 9    //允许修改文件的不可修改(IMMUTABLE)和只添加(APPEND-ONLY)属性  
CAP_NET_BIND_SERVICE 10   //允许绑定到小于1024的端口  
CAP_NET_BROADCAST    11   //允许网络广播和多播访问  
CAP_NET_ADMIN        12   //允许执行网络管理任务：接口、防火墙和路由等  
CAP_NET_RAW          13   //允许使用原始(raw)套接字  
CAP_IPC_LOCK         14   //允许锁定共享内存片段  
CAP_IPC_OWNER        15   //忽略IPC所有权检查  
CAP_SYS_MODULE       16   //插入和删除内核模块  
CAP_SYS_RAWIO        17   //允许对ioperm/iopl的访问  
CAP_SYS_CHROOT       18   //允许使用chroot()系统调用  
CAP_SYS_PTRACE       19   //允许跟踪任何进程  
CAP_SYS_PACCT        20   //允许配置进程记帐(process accounting)  
CAP_SYS_ADMIN        21   //允许执行系统管理任务：加载/卸载文件系统、设置磁盘配额、开/关交换设备和文件等
CAP_SYS_BOOT         22    //允许重新启动系统  
CAP_SYS_NICE         23    //允许提升优先级，设置其它进程的优先级  
CAP_SYS_RESOURCE     24    //忽略资源限制  
CAP_SYS_TIME         25    //允许改变系统时钟  
CAP_SYS_TTY_CONFIG   26    //允许配置TTY设备  
CAP_MKNOD            27    //允许使用mknod()系统调用  
CAP_LEASE            28    //允许取消文件上的租借期

内核提供了两个系统调用sys_capget和sys_capset来得到或设置指定PID或所有进程的能力，这两个函数都是通过对进程任务结构task_struct中的能力变量进行操作来实现的。

　　在kernel/capability.c中有全局变量cap_bset设置进程初始的能力，这个变量列出如下：

kernel_cap_t cap_bset = CAP_INIT_EFF_SET;

用户可以在/proc/sys/kernel/cap-bound文件中可看到系统保留的能力。在默认情况下，所有的位都是打开的。在内核内存区中，/proc/sys/kernel/cap-bound直接映射到cap_bset变量中。

　　root用户可以删除系统保留的能力。却不能再恢复被删除的能力，只有init进程能够添加能力。通常，一个能力如果从能力边界集中被删除，只有系统重新启动才能恢复。

用户可通过shell命令行设置能力。例如：禁止加载/卸载任何内核模块，CAP_SYS_MODULE能力的值是16，可用下列命令完成：

[root@]# echo 0xFFFEFFFF >/proc/sys/kernel/cap-bound

 

2.2 能力机制操作函数集

Linux对能力的操作函数定义在操作函数集capability_ops，其列出如下（在linux26/security/capability.c中）：

static struct security_operations capability_ops = {
	.ptrace =			cap_ptrace,    //检查是否有执行ptrace的能力
	.capget =			cap_capget,　　//返回有效能力、允许能力和可继承能力的能力值
     //能力集检查，有效能力应是允许能力的子集，可继承能力应是当前进程与目标进程能力集的子集
	.capset_check =	cap_capset_check,　
	.capset_set =		cap_capset_set,　 //给目标进程设置有效能力、允许能力和可继承能力
	.capable =		cap_capable,　　　//检查进程是否具有函数参数指定的能力
	.settime =		cap_settime,　　　//检查是否有设置时间的能力
　　　//设置结构netlink_skb_parms的成员eff_cap为当前进程的有效能力
	.netlink_send =	cap_netlink_send,　
	.netlink_recv =	cap_netlink_recv,　 //检查成员eff_cap是否具有函数参数指定的能力
 
	.bprm_apply_creds =	cap_bprm_apply_creds,　//设置二进制应用程序运行时的能力集
	.bprm_set_security =	cap_bprm_set_security,　//给进程设置能力集
	.bprm_secureexec =		cap_bprm_secureexec,//检查当前进程uid与euid、gid与egid是否相等
 
	.inode_setxattr =		cap_inode_setxattr,　//检查是否有系统管理员的能力
	.inode_removexattr =	cap_inode_removexattr, //检查是否有系统管理员的能力
 
　　　//以前是root，当前进程是非root用户，清除有效能力
	.task_post_setuid =		cap_task_post_setuid,　
	.task_reparent_to_init =	cap_task_reparent_to_init,
 
	.syslog =                       cap_syslog,　 //检查是否有系统管理员的能力
 
　　　//检查是否有系统管理员的能力及足够的页
	.vm_enough_memory =             cap_vm_enough_memory,　 
};

进程运行时，通过检查进程的有效能力集tsk->cap_effective的能力位，判断进程是否具有相应的能力。检查能力的通用函数cap_capable列出如下：

int cap_capable (struct task_struct *tsk, int cap)
{
 
	if (cap_raised(tsk->cap_effective, cap))　　//比较能力对应的位
		return 0;
	return -EPERM;
}
 
#define CAP_TO_MASK(x) (1 << (x�
#define cap_raised(c, flag)  (cap_t(c) & CAP_TO_MASK(flag�

 

2.3 应用程序运行设置信任值

二进制应用程序运行时，Linux内核会调用函数load_elf_binary装载执行二进制elf格式文件。函数load_elf_binary执行时，会调用函数compute_creds设置新运行进程的信任值，包括uid、gid、能力集、安全ID、密钥环等。函数compute_creds的调用层次图如图5。

 

图5　函数compute_creds的调用层次图

函数compute_creds计算并设置当前进程的信任值，然后设置信号、资源限制，唤醒等待的父进程。其列出如下（在linux26/fs/exec.c中）：

void compute_creds(struct linux_binprm *bprm)
{
	int unsafe;
 
	if (bprm->e_uid != current->uid)
		suid_keys(current);　//目前函数未实现，仅返回0
	exec_keys(current);
 
	task_lock(current);
　　//如果当前进程的文件或信号处理等的引用计数超过1，将unsafe设置为LSM_UNSAFE_SHARE，表示非安全共享
	unsafe = unsafe_exec(current);
	security_bprm_apply_creds(bprm, unsafe);　//设置当前进程的能力集、uid、gid和sid
	task_unlock(current);
　　//如果有不安全因素，杀死当前进程，否则，设置信号、资源限制、唤醒等待的父进程
	security_bprm_post_apply_creds(bprm);  
}

新运行的进程应清空线程密钥环和进程密钥环。清除函数exec_keys列出如下（在linux26/security/keys/process_keys.c中）：

int exec_keys(struct task_struct *tsk)
{
	struct key *old;
 
	/*新运行的任务没有线程密钥环*/
	task_lock(tsk);
	old = tsk->thread_keyring;
	tsk->thread_keyring = NULL;  //进程的线程密钥环设置为空
	task_unlock(tsk);
 
	key_put(old);　　//清除进程旧的线程密钥环
 
	/* 新运行的进程删除进程密钥环*/
	spin_lock_irq(&tsk->sighand->siglock);
	old = tsk->signal->process_keyring;
	tsk->signal->process_keyring = NULL;　　//进程密钥环设置为空
	spin_unlock_irq(&tsk->sighand->siglock);
 
	key_put(old);  //清除旧的进程密钥环
 
	return 0;
 
}

函数selinux_bprm_apply_creds给当前进程设置uid、gid、能力集和sid。其列出如下（在linux26/security/capability.c中）：

static void selinux_bprm_apply_creds(struct linux_binprm *bprm, int unsafe)
{
	struct task_security_struct *tsec;
	struct bprm_security_struct *bsec;
	u32 sid;
	int rc;
 
	secondary_ops->bprm_apply_creds(bprm, unsafe);　//设置uid、gid和能力集
 
	tsec = current->security;
 
	bsec = bprm->security;
	sid = bsec->sid;
 
	tsec->osid = tsec->sid;
	bsec->unsafe = 0;
	if (tsec->sid != sid) {
		/* 检查共享状态，如果检查进程有共享权限，不改变sid*/
		if (unsafe & LSM_UNSAFE_SHARE) {
			rc = avc_has_perm(tsec->sid, sid, SECCLASS_PROCESS,
					PROCESS__SHARE, NULL);
			if (rc) {
				bsec->unsafe = 1;
				return;
			}
		}
 
		/* 检查有ptrace权限，不改变sid */
		if (unsafe & (LSM_UNSAFE_PTRACE | LSM_UNSAFE_PTRACE_CAP)) {
			rc = avc_has_perm(tsec->ptrace_sid, sid,
					  SECCLASS_PROCESS, PROCESS__PTRACE,
					  NULL);
			if (rc) {
				bsec->unsafe = 1;　//表示不安全，随后的函数后杀死当前进程
				return;
			}
		}
		tsec->sid = sid;　　//设置进程的sid为bprm的sid，即设置为来自文件的sid
	}
}

函数cap_bprm_apply_creds设置当前进程的uid、gid和能力集。二进制文件通过调用函数fork()，产生新的进程，这个新的进程为当前进程。

当前进程的uid和gid来自于文件系统的uid和gid。

当前进程的能力集来自于父进程的能力集、系统的缺省能力集cap_bset和linux_binprm的能力集。结构linux_binprm存储二进制文件执行时产生的各种参数。当前进程能力集的计算逻辑公式列出如下：

current->cap_permitted = �(bprm->cap_permitted) ∩ cap_bset) ∪) ∩ (current->cap_permitted)

current->cap_effective = (current->cap_permitted) ∩(current->cap_permitted)

函数cap_bprm_apply_creds列出如下（在linux26/security/commoncap.c中）：

void cap_bprm_apply_creds (struct linux_binprm *bprm, int unsafe)
{
	/* Derived from fs/exec.c:compute_creds. */
	kernel_cap_t new_permitted, working;
　　//cap_bset是存放能力集的全局变量，表示系统的能力集
　　//得到bprm->cap_permitted与cap_bset的交叉集合
	new_permitted = cap_intersect (bprm->cap_permitted, cap_bset);
	working = cap_intersect (bprm->cap_inheritable,
				 current->cap_inheritable);
　　//表示得到new_permitted和working的合并集合
	new_permitted = cap_combine (new_permitted, working);
 
	if (bprm->e_uid != current->uid || bprm->e_gid != current->gid ||
　　　　//判断new_permitted是否是current->cap_permitted的子集
	    !cap_issubset (new_permitted, current->cap_permitted)) {
		current->mm->dumpable = suid_dumpable;
 
		if (unsafe & ~LSM_UNSAFE_PTRACE_CAP) {
			if (!capable(CAP_SETUID)) {　//检查是否有设置uid能力的标识CAP_SETUID
				bprm->e_uid = current->uid;　//设置uid
				bprm->e_gid = current->gid;
			}
			if (!capable (CAP_SETPCAP)) { //如果有设置进程能力集的能力
				new_permitted = cap_intersect (new_permitted,
							current->cap_permitted);
			}
		}
	}
　　　
	current->suid = current->euid = current->fsuid = bprm->e_uid;　　//设置uid
	current->sgid = current->egid = current->fsgid = bprm->e_gid;    //设置gid
 
	/*init进程需要保留init_task中初始化的能力集，不需要再设置*/
	if (!is_init(current)) {　　//如果是非init进程，设置能力集
		current->cap_permitted = new_permitted;
		current->cap_effective =
		    cap_intersect (new_permitted, bprm->cap_effective);
	}
 
	current->keep_capabilities = 0; //表示不需要保持能力集
}

函数selinux_bprm_post_apply_creds在设置信任值后调用，用来设置信号、资源限制、唤醒等待的父进程。其列出如下：

static void selinux_bprm_post_apply_creds(struct linux_binprm *bprm)
{
	struct task_security_struct *tsec;
	struct rlimit *rlim, *initrlim;
	struct itimerval itimer;
	struct bprm_security_struct *bsec;
	int rc, i;
 
	tsec = current->security;
	bsec = bprm->security;
 
	if (bsec->unsafe) {　　//如果存在不安全因素
		force_sig_specific(SIGKILL, current);　//发信号SIGKILL杀死当前进程
		return;
	}
	if (tsec->osid == tsec->sid)
		return;
 
	/*关闭文件，因为新进程的sid未被授权*/
	flush_unauthorized_files(current->files);
 
	/*检查新sid能否从旧的sid继承信号状态，如果不能，清除itimers，避免随后信号产生、刷新和非阻塞信号。这发生在进程sid已更新之后，sid更新以便在对新sid检查flush后完成任何kill操作*/
	rc = avc_has_perm(tsec->osid, tsec->sid, SECCLASS_PROCESS,
			  PROCESS__SIGINH, NULL);
	if (rc) {
		memset(&itimer, 0, sizeof itimer);
		for (i = 0; i < 3; i++)
			do_setitimer(i, &itimer, NULL);
		flush_signals(current);
		spin_lock_irq(&current->sighand->siglock);
		flush_signal_handlers(current, 1);　//1表示强制执行
		sigemptyset(&current->blocked);    //清空阻塞的信号
		recalc_sigpending();   //重计算当前进程的挂起状态，并设置或清除TIF_SIGPENDING信号
		spin_unlock_irq(&current->sighand->siglock);
	}
 
	/*检查新sid是否能从旧的sid继承资源限制。如果不能，将重设置所有软件限制到较低值，这个较低值是当前进程的硬件限制和init进程的软件限制的较小者*/
	rc = avc_has_perm(tsec->osid, tsec->sid, SECCLASS_PROCESS,
			  PROCESS__RLIMITINH, NULL);
	if (rc) {
		for (i = 0; i < RLIM_NLIMITS; i++) {
			rlim = current->signal->rlim + i;
			initrlim = init_task.signal->rlim+i;
			rlim->rlim_cur = min(rlim->rlim_max,initrlim->rlim_cur);
		}
		if (current->signal->rlim[RLIMIT_CPU].rlim_cur != RLIM_INFINITY) {
			/*这将引起RLIMIT_CPU计算再次进行*/
			current->it_prof_expires = jiffies_to_cputime(1);
		}
	}
 
	/*如果父进程正在等待，以便能再次对新进程sid检查等待许可，唤醒父进程*/
	wake_up_interruptible(&current->parent->signal->wait_chldexit);
}

 

3 ACL权限管理

由于UGO 权限管理方式只能对属主、同组用户和其他组用户进行权限管理，很难对每个用户或用户组进行权限管理，这种局限性导致了ACL的产生。

ACL（Access Control List，访问控制列表）基于IEEE POSIX 1003.1e标准，它对UGO 权限管理方式进行了扩展，可以对任意的用户/组分配读、写和执行操作权限。EXT2/EXT3/EXT4、JFS、XFS和ReiserFS等文件系统都支持ACL。当设置了ACL属性并用命令ls -l查看文件时，ACL属性表现为UGO权限位末尾的‘+’符号。

为了让文件系统支持ACL，在挂载分区时需要添加参数"acl"。手动挂接的命令如下：

mount -t ext3 -o rw,acl /dev/hda8 /your_mount_point

还可以在文件/etc/fstab中加入下列行，系统启动时会自动挂接文件系统：

/dev/hda8 ext3 /your_mount_point defaults,acl 1 1

3.1　ACL权限管理命令

ACL权限管理使用命令getfacl查看ACL属性，使用命令setfacl设置ACL属性。下面分别说明这两个命令。

（1）命令getfacl

命令getfacl用来显示文件名、所有者、组和访问控制列表。如果一个目录有缺省的ACL，它将显示缺省的ACL。非目录没有缺省ACL。如果getfacl用于不支持ACL的文件系统，它将显示传统的UGO 权限管理方式的权限位信息。

例如：命令getfacl取得文件test的ACL信息的方法如下：

^-^$ getfacl test

# file: test
# owner: root
# group: root
user::rw-
group::r--
other::r--

（2）命令setfacl

命令setfacl用来设置文件访问控制列表，命令格式如下：

setfacl [-bkndRLPvh] [{-m|-x} acl_spec] [{-M|-X} acl_file] file ...
       setfacl --restore=file

其中，选项-m和-M表示修改ACL，-x和-X表示删除ACL条目。详细说明请参考man文档。如果在不支持ACL的文件系统使用命令setfacl，它以最接近于ACL的权限修改权限位。

例如，一个设置ACL的命令列出如下：

^-^$ setfacl -m u:testu:wr test

上面的命令表示对于test文件，给用户testu设置了读和写权限。使用命令ls -l查看，可发现权限位的末尾多出了一个‘+’符号，它表示设置了ACL。命令ls -l列出如下：

^-^$ ls -l

-rw-rw-r--+ 1 root root 0 Feb 8 18:20 test

再使用命令getfacl查看ACL信息，发现给testu用户设置了读写权限。命令getfacl列出如下：

^-^$ getfacl test
# file: test
# owner: root
# group: root
user::rw-
user:testu:rw-
group::r--
mask::rw-
other::r--

从上例可以看出，每次使用命令getfacl后，getfacl还设置了mask（掩码），还可以在命令中单独使用mask项来设置掩码。通常，掩码的值与命令getfacl设置的权限值一致。掩码与用户的权限位值进行与逻辑操作后，最终决定文件的操作权限。

如果命令setfacl不指定操作用户，则表示对默认属主用户权限的操作，使用命令setfacl可实现功能上和命令chmod相同操作。例如setfacl u::rwx,g::rwx,o::rwx test等价于chmod 777 test。

 

3.2　命令getfacl和setfacl机制分析

命令getfacl通过调用libacl库的函数acl_get_file得到每个文件的ACL信息；命令setfacl通过调用libacl库的函数acl_set_file设置每个文件的ACL信息。ACL信息存储在文件系统的节点的扩展属性中，不同类型的文件系统，节点数据以不同的形式存放于硬盘　上。

函数acl_get_file与acl_set_file进行方向相反的操作，函数acl_get_file调用文件系统的系统调用函数getxattr，从节点的扩展属性中得到ACL信息，然后转换成本地的ACL信息结构，最后，由命令getfacl将本地的ACL信息结构转换成适合显示的格式。

命令acl_set_file将用户输入的信息转换成本地ACL信息结构，接着，函数acl_set_file再将本地ACL信息结构转换成文件系统的ACL信息结构，然后，将ACL信息更新到节点的扩展属性中。

由于函数acl_get_file与acl_set_file的机制类似，操作方向相反，因此，下面仅分析函数acl_get_file。

函数acl_get_file得到一个文件或目录文件的ACL数据。如果节点存在扩展属性，它将调用文件系统的系统调用函数getxattr从扩展属性中提取ACL数据。如果扩展属性不存在，它将调用函数stat从节点的属性读取权限信息位数据，并调用函数acl_from_mode将它转换成ACL数据。

函数acl_get_file的调用层次图如图3。图3中，在函数getxattr以后的调用函数进入内核空间。在内核空间，虚拟文件系统的函数vfs_getxattr调用再直接调用具体文件系统的节点操作函数集的函数inode->i_op->getxattr(...)读取节点的扩展属性。

 

 

图3　函数acl_get_file的调用层次图

文件系统的ACL信息结构由一个属性头和多个属性条目组成，节点的操作函数getxattr根据ACL类型，调用相应的ACL操作函数，从扩展属性中解释出ACL数据。这个ACL信息分别用结构acl_ea_header和acl_ea_entry描述。其列出如下（在acl/include/acl_ea.h中）：

typedef struct {　　　　　　　　//ACL头结构
	u_int32_t a_version;　　　　//版本
	acl_ea_entry	a_entries[0];//ACL条目的指针
} acl_ea_header;
 
typedef struct {　　　　　　　//ACL条目结构
	u_int16_t	 e_tag;　　　　　//标签值
	u_int16_t	 e_perm;　　　　//操作许可值
	u_int32_t	 e_id;　　　　　//ID，如：用户ID、组ID等
} acl_ea_entry;

函数acl_get_file先设置猜测的ACL条目数，因为大多数情况下，文件ACL的条目数不会超过16个。然后分配猜测数计算出的内存空间。接着，它调用函数getxattr得到文件的ACL条目数，并验证猜测的条目数是否合适。如果实际的条目数比猜测的条目数大，则按实际的条目数重新计算并分配分配，再调用getxattr得到文件的ACL信息。这样，大多数情况下，只需要调用一次函数getxattr，就可得到ACL信息，提高了执行效率。

函数acl_get_file列出如下（在acl/libacl/acl_get_file.c中）：

acl_t　acl_get_file(const char *path_p, acl_type_t type)
{
　　//猜测有16条ACL条目，并计算分配空间大小，后面再检查猜测是否正确
	const size_t size_guess = acl_ea_size(16);　
	char *ext_acl_p = alloca(size_guess);　//分配空间
	const char *name;
	int retval;
 
	switch(type) {
		case ACL_TYPE_ACCESS:　//访问的ACL类型
			name = ACL_EA_ACCESS;
			break;
		case ACL_TYPE_DEFAULT:　//缺省的ACL类型
			name = ACL_EA_DEFAULT;
			break;
		default:
			errno = EINVAL;
			return NULL;
	}
 
	if (!ext_acl_p)
		return NULL;
	retval = getxattr(path_p, name, ext_acl_p, size_guess);
	if (retval == -1 && errno == ERANGE) {　//条目数超过了猜测的条目数，需要重新分配空间
		retval = getxattr(path_p, name, NULL, 0);
		if (retval > 0) {　　//返回ACL的条目数
			ext_acl_p = alloca(retval);　//重分配空间
			if (!ext_acl_p)
				return NULL;
			retval = getxattr(path_p, name, ext_acl_p, retval); //再读取ACL条目
		}
	}
	if (retval > 0) {
		acl_t acl = __acl_from_xattr(ext_acl_p, retval);　//转换成本地结构的ACL数据
		return acl;
	} else if (retval == 0 || errno == ENOATTR || errno == ENODATA) {//没有ACL数据
		struct stat st;
 
		if (stat(path_p, &st) != 0)　　//读取文件的属性数据
			return NULL;
 
		if (type == ACL_TYPE_DEFAULT) {　　//如果为缺省的ACL类型
　　　　　　　/*只有目录有缺省的ACL类型*/
			if (S_ISDIR(st.st_mode)) //如果是目录
				return acl_init(0);　//初始化为0个条目的ACL
			else {　//出错，给出错误号
				errno = EACCES;
				return NULL;
			}
		} else
			return acl_from_mode(st.st_mode);　//从文件的属性数据中提取授权信息，生成ACL
	} else
		return NULL;
}

 

3.3 文件系统检查ACL权限

文件系统的节点操作函数集结构含有操作许可函数指针permission，它指向具体文件系统的操作许可函数，用来检查文件或目录的操作权限。对于ext4文件系统来说，它是函数ext4_permission。

函数ext4_permission列出如下（在linux26/fs/ext4/acl.c中）：

int ext4_permission(struct inode *inode, int mask, struct nameidata *nd)
{
	return generic_permission(inode, mask, ext4_check_acl);
}

函数generic_permission检查符合posix标准的文件系统的访问权限。参数inode为检查访问权限的节点，参数mask为检查的权限（值为MAY_READ、MAY_WRITE、MAY_EXEC，分别定义为1、2、4）。参数check_acl为检查符合posix标准的的ACL的回调函数，是可选的。

函数generic_permission检查一个文件的读、写、执行权限。对于ext4文件系统，它调用函数ext4_check_acl完成ACL权限检查。其列出如下（在linux26/fs/namei.c中）：

int generic_permission(struct inode *inode, int mask,
		int (*check_acl)(struct inode *inode, int mask))
{
	umode_t	mode = inode->i_mode;　　//从节点中得到访问模式
 
	if (current->fsuid == inode->i_uid)//如果当前进程的fsuid与节点的uid一致，用户为所有者
		mode >>= 6;　　　//右移6位，得到文件所有者的权限位
	else {　　//非文件所有者
		if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {　　//ACL模式
　　　　　　　//对于ext4文件系统，check_acl指向函数ext4_check_acl
			int error = check_acl(inode, mask);　　//检查ACL用户的权限位
			if (error == -EACCES)　　
				goto check_capabilities;
			else if (error != -EAGAIN)
				return error;
		}
 
		if (in_group_p(inode->i_gid))　//检查当前进程的fsgid与节点gid是否相符
			mode >>= 3;　　//得到同组的权限位
	}
 
	/*如果访问权限是否是读、写、执行，说明DAC检查OK，不需要能力检查*/
	if (((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask))
		return 0;
 
 check_capabilities:　　//能力检查
	/*读/写表明总是可以覆盖写的 */
	if (!(mask & MAY_EXEC) ||　　　　　　　　　//mask表示需要检查的权限
	    (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
		if (capable(CAP_DAC_OVERRIDE))　//有覆盖写的能力
			return 0;
 
	if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
		if (capable(CAP_DAC_READ_SEARCH))　//有读和搜索的能力
			return 0;
 
	return -EACCES;
}

不同文件系统的节点在硬盘中存储方式不一样，结构inode有一些不同的成员。因此，检查ACL需要调用不同文件系统的实现函数。ext4文件系统检查ACL的函数是ext4_check_acl，它从结构inode中读取ACL信息成员，检查是否有权限允许访问。

函数ext4_check_acl列出如下（在linux26/fs/ext4/acl.c中）：

static int
ext4_check_acl(struct inode *inode, int mask)
{
    　//从节点inode中读取acl，如果inode不在内存中，从硬盘中读取节点到内存中
	struct posix_acl *acl = ext4_get_acl(inode, ACL_TYPE_ACCESS);
 
	if (IS_ERR(acl))
		return PTR_ERR(acl);
	if (acl) {
		int error = posix_acl_permission(inode, acl, mask);　//检查acl是否允许访问
		posix_acl_release(acl);　//释放acl
		return error;
	}
 
	return -EAGAIN;
}