La estructura de atributos de archivos se muestra a continuación. A través de esta figura, podemos tener una comprensión global de la estructura de atributos de archivos de los sistemas operativos tipo Unix. Este blog no solo presentará algunos atributos de uso común, sino que también presentará algunos permisos especiales que son fáciles de usar. pasado por alto.
tipo de archivo 0x10
Linux El primer carácter representa el tipo de archivo.
- [ d ] -> directorio, directorio
- [ - ] -> Archivo normal
- [ l ] -> enlace, enlace de archivo
- [ b ] -> bloquear, bloquear dispositivos, como el disco duro y la memoria
- [c] -> capítulo, dispositivos de caracteres como teclado y mouse
- [ s ] -> socket, socket, flujo de red
Permisos de archivos 0x20
Seguido de un grupo de tres, cada grupo es una combinación de [rwx], que indica permisos de archivo , es decir read/write/execute, si no hay permiso, es [-]. El tipo de archivo y los atributos del archivo se identifican mediante 10 caracteres.
Los permisos de llamada de archivos de Linux/Unix se dividen en tres niveles: propietario del archivo (Propietario), grupo de usuarios (Grupo) y otros usuarios (Otros usuarios).
Sólo el propietario del archivo y el superusuario pueden modificar los permisos de un archivo o directorio . Puede utilizar el modo absoluto (modo de número octal) y el modo simbólico para especificar permisos de archivos.
0x21 Línea de comando para modificar permisos de archivos
1 mascarilla octal
Históricamente, se ha utilizado un número binario de 3 dígitos para representar el permiso rwx, como se muestra a continuación, que puede representar todos los conjuntos de permisos, |r|w|x|, cuya posición es 1, lo que indica que tiene el permiso.
| # | Permisos | rwx | binario |
|---|---|---|---|
| 7 | Leer+Escribir+Ejecutar | rwx | 111 |
| 6 | leer + escribir | rw- | 110 |
| 5 | Leer+Ejecutar | RX | 101 |
| 4 | solo lectura | r– | 100 |
| 3 | escribir + ejecutar | -wx | 011 |
| 2 | solo escribe | -w- | 010 |
| 1 | Ejecutar solo | -X | 001 |
| 0 | ninguno | — | 000 |
Por lo tanto, chmod puede modificar los permisos de los archivos usando una máscara octal simple, por ejemplo.
chmod 777 test.txt # -rwxrwxrwx，所有人可读可写可执行
chmod 666 test.txt # -rw-rw-rw-
modo de 2 símbolos
El modo simbólico puede ser más fácil de recordar para los principiantes. Al utilizar el modo simbólico, puede configurar varios elementos: quién (tipo de usuario), operador (operador) y permiso (permiso). Las configuraciones para cada elemento se pueden separar por comas.
La tabla de patrones de símbolos para who es la siguiente:
| OMS | tipo de usuario | ilustrar |
|---|---|---|
u |
usuario | Propietario del archivo |
g |
grupo | Grupo del propietario del archivo |
o |
otros | todos los demás usuarios |
a |
todo | El usuario utilizado es equivalente a ugo. |
Tabla de patrones de símbolos para el operador:
| Operador | ilustrar |
|---|---|
+ |
Agregar permisos al tipo de usuario especificado |
- |
Eliminar permisos de un tipo de usuario específico |
= |
Establecer la configuración para los permisos de usuario especificados, es decir, restablecer todos los permisos para el tipo de usuario |
Tabla de patrones de símbolos de permiso:
| modelo | nombre | ilustrar |
|---|---|---|
r |
leer | Establecer como permiso de lectura |
w |
Escribir | Establecer permisos de escritura |
x |
permiso de ejecución | Establecer permisos ejecutables |
X |
permisos especiales de ejecución | Establezca los permisos de archivo en ejecutables solo cuando el archivo sea un archivo de directorio u otros tipos de usuarios tengan permisos ejecutables. |
s |
setuid/gid | Cuando se ejecuta el archivo, los permisos setuid o setgid del archivo se establecen de acuerdo con el tipo de usuario especificado por el parámetro who. |
t |
Pegar poco | Establece el bit de pegado. Solo el superusuario puede configurar este bit. Solo el propietario del archivo puede utilizar este bit. |
ejemplo del comando chmod
chmod ugo+r test.txt # -rwxrwxrwx，所有人可读可写可执行
0x22 Permisos de archivo de modificación de código
Linux proporciona llamadas al sistema chmodpara modificar permisos de archivos. Consulte el Manual de programación de Linux ( man 2 chmod). Las funciones proporcionadas para modificar permisos son las siguientes:
#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
int fchmod(int fd, mode_t mode);
#include <fcntl.h> /* Definition of AT_* constants */
#include <sys/stat.h>
int fchmodat(int dirfd, const char *pathname, mode_t mode, int flags);
chmodLa función solo necesita proporcionar el nombre del archivo y los permisos de modificación, mientras que fchmodprimero debe abrir el archivo y obtener el identificador del archivo antes de usarlo. Según la seguridad del sistema, si desea escribir datos en un archivo ejecutable y el archivo ejecutable tiene permisos S_ISUID o S_ISGID, estos dos bits se borrarán. Si un directorio tiene el permiso de bits S_ISUID, significa que solo el propietario o la raíz del archivo en este directorio puede eliminar el archivo.
chmod("/testdir/aaa.txt", S_IRUSR|S_IWUSR|S_IRGRP|S_IRGRP|S_IROTH|S_IWOTH); // 666o
El modo de parámetro tiene las siguientes combinaciones:
- Bit de archivo S_ISUID 04000 (establecer ID de usuario durante la ejecución)
- Bit de archivo S_ISGID 02000 (establecer ID de grupo en ejecución)
- S_ISVTX 01000 bit adhesivo de archivo
- S_IRUSR (S_IREAD) 00400 El propietario del archivo tiene permisos de lectura
- S_IWUSR (S_IWRITE)00200 El propietario del archivo tiene permisos de escritura
- S_IXUSR (S_IEXEC) 00100 El propietario del archivo tiene permisos ejecutables
- El grupo de usuarios S_IRGRP 00040 tiene permisos de lectura
- El grupo de usuarios S_IWGRP 00020 tiene permisos de escritura
- El grupo de usuarios S_IXGRP 00010 tiene permisos ejecutables
- S_IROTH 00004 Otros usuarios tienen permisos de lectura
- S_IWOTH 00002 Otros usuarios tienen permisos de escritura
- S_IXOTH 00001 Otros usuarios tienen permisos ejecutables
Por ejemplo, al revertir IDA, necesitamos modemodificar los parámetros a la representación octal, para que podamos ver fácilmente sus permisos.
propietario del archivo 0x30
Linux/Unix es un sistema operativo multitarea y para varias personas, y todos los archivos tienen propietarios. Utilice chown para cambiar el propietario del archivo especificado al usuario o grupo especificado. El usuario puede ser el nombre de usuario o el ID de usuario ( UID ). El grupo puede ser el nombre del grupo o el ID de grupo ( GID ). Los archivos están separados por espacios para cambiar permisos. Lista de archivos, admite caracteres comodín.
1. chgrp: cambia el grupo de archivos
chgrp [OPTION]... GROUP FILE...
Parámetros comunes
- -R, cambia recursivamente el grupo de archivos. Si cambia el grupo de un directorio, se cambiará el grupo de todos los archivos en el directorio. Este parámetro también se usa a menudo en otros comandos de Linux.
2. chown: cambiar el propietario/grupo del archivo
chown [OPTION]... [OWNER][:[GROUP]] FILE...
0x40 permisos especiales
Como todos sabemos, los permisos de archivos de Linux son como: 777, 666, etc. De hecho, siempre que se agregue el permiso UID al archivo correspondiente, el archivo se puede ejecutar como la persona que agregó el permiso. Entonces solo necesitamos copiar bash a otro lugar y luego usar root para agregar permisos UID. Siempre que el usuario ejecute este shell, puede ejecutar cualquier archivo como root.
Este método se puede utilizar para escalar privilegios.
0x41 setuid/setgid (rws)
En términos generales, quien llama al archivo solo tiene los permisos del propietario del archivo . Esto se especifica en las propiedades del archivo. Entonces aquí viene la pregunta: por ejemplo, si un usuario común quiere cambiar su contraseña y descubre que el archivo que guarda la configuración de la contraseña no puede ser escrito por usuarios comunes, entonces, en teoría, los usuarios comunes ni siquiera pueden cambiar sus propias contraseñas.
$ ls -lh /etc/passwd
-rw-r--r-- 1 root root 3.2K Jan 14 11:30 /etc/passwd
Y setuidpuedo setgidcambiar esta configuración, lo que equivale a cambiar el propietario del archivo cuando el programa se está ejecutando . Echemos un vistazo al binario utilizado para cambiar contraseñas.
$ ls -lh /usr/bin/passwd
-rwsr-xr-x 1 root root 63K Feb 7 2020 /usr/bin/passwd
用户属主的权限位 x 是 s，这里的 s 意思是其他用户运行此命令时，会临时具有 root 用户的权限运行此文件
- setuid：让普通用户可以以 root 用户的角色运行只有 root 帐号才能运行的程序或命令
- setgid：该权限只对目录有效。目录被设置该位后，任何用户在此目录下创建的文件都具有和该目录所属的组相同的组
0x42 Sticky Bit (rwt)
In Unix-like operating systems, a sticky bit is a permission bit which is set on a file or folder, thereby permitting only the owner or root user of the file or folder to modify, rename or delete the concerned directory or file. No other user would be permitted to have these privileges on a file which has a sticky bit. In Unix-like systems, without the sticky bit on, any user can modify, rename or delete the directory or file regardless of the owner of the file or folder.
类 Unix 操作系统中的文件权限，读写可执行，其中的写和执行权限，就代表了重命名、删除文件的权限。而设置了 Sticky Bit 的文件，只有文件、目录所有者或者 root 才能够有权限重命名或删除该文件。
例如 Linux 文件系统根目录下的 tmp 目录
$ ls -lh / | grep tmp
drwxrwxrwt 13 root root 12K Feb 8 15:09 tmp
如果本来该位上有 x，则特殊位显示小写字母（s, s, t），否则显示大写字母（S，S，T）。即 rws/rwS。
0x43 延伸：具有写权限却不能写入文件
某天在测试某个设备时，突然发现一个问题，明明对该文件具有写的权限，但是却不能写入信息
$ ls -lh /tmp/my.log
-rw-rw-rw- 1 lys lys 0 2月 8 15:48 my.log
我们是以 jerry 的身份修改 my.log ，代码如下
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
int main(int argc, char const *argv[])
{
char *name = "/tmp/my.log";
FILE *fp = fopen(name, "a+");
if(fp == NULL) {
fprintf(stderr, "Couldn't open: %s: %s\n", name, strerror(errno));
}
else
fclose(fp);
return 0;
}
运行该程序
$ ./test
Couldn't open: /tmp/my.log: Permission denied
这个问题来源于在 Linux 4.19 内核引入的一个内核参数 this commit ，fs.protected_regular，用于禁止在全局可写 Sticky Bit 目录中打开不属于用户的 FIFO 或常规文件。相关文档位于 Documentation/sysctl/fs.txt
protected_fifos:
The intent of this protection is to avoid unintentional writes to an attacker-controlled FIFO, where a program expected to create a regular file.
…
protected_regular:
This protection is similar to protected_fifos, but it avoids writes to an attacker-controlled regular file, where a program expected to create one.
When set to “0”, writing to regular files is unrestricted.
When set to “1” don’t allow O_CREAT open on regular files that we don’t own in world writable sticky directories, unless they are owned by the owner of the directory.
When set to “2” it also applies to group writable sticky directories.
即这个保护可以用以下命令关闭
sysctl fs.protected_regular=0
这个特性用于缓解以下漏洞
- CVE-2000-1134
- CVE-2007-3852
- CVE-2008-0525
- CVE-2009-0416
- CVE-2011-4834
- CVE-2015-1838
- CVE-2015-7442
- CVE-2016-7489
由于一些开发者没有注意到该特性，会导致一些空指针问题，例如如下代码
当一个用户运行此程序，会试图创建该文件，并将该文件的权限修改为 -rw-rw-rw- 。当另外一个用户运行此程序，按照正常逻辑，该文件已经存在，因此不需要创建，直接就会打开，但是其实是空指针。fclose 时报错。
0x50 索引节点
0x51 inode
索引节点的英文名 inode(index node)，其实输入命令 ls -li 就可以看到文件的索引节点。
ls -lhi ~
total 617M
2360250 -rw-r--r-- 1 lys lys 0 Jan 6 17:47 123
2360331 -rwxr-xr-x 1 lys lys 68M Apr 15 2021 code_1.55.2-1618307277_amd64.deb
Linux 文件系统类型有 ext2/3/4，每个存储设备或分区被格式化后，创建为一个新的文件系统，其实这个过程包含两部分：创建 inode，创建 block。inode 用于定位文件位置，block 用于存放实际的文件内容。inode 就是一块存储空间，不同操作系统默认大小不一样。
查看文件系统分区及类型
$ df -Th
Filesystem Type Size Used Avail Use% Mounted on
udev devtmpfs 3.9G 0 3.9G 0% /dev
tmpfs tmpfs 797M 996K 796M 1% /run
/dev/sda1 ext4 62G 56G 3.0G 95% /
tmpfs tmpfs 3.9G 0 3.9G 0% /dev/shm
tmpfs tmpfs 5.0M 0 5.0M 0% /run/lock
tmpfs tmpfs 4.0M 0 4.0M 0% /sys/fs/cgroup
tmpfs tmpfs 797M 56K 797M 1% /run/user/1000
查看指定文件 inode
$ stat 123
File: 123
Size: 5 Blocks: 8 IO Block: 4096 regular file
Device: 801h/2049d Inode: 2360250 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1000/ lys) Gid: ( 1000/ lys)
Access: 2022-01-14 20:06:21.610734953 +0800
Modify: 2022-02-08 20:36:41.541211863 +0800
Change: 2022-02-08 20:36:41.541211863 +0800
Birth: 2022-01-06 20:47:18.455172720 +0800
查看系统分区 inode 使用情况
$ df -i
Filesystem Inodes IUsed IFree IUse% Mounted on
udev 1010848 381 1010467 1% /dev
tmpfs 1019341 628 1018713 1% /run
/dev/sda1 4136960 1265184 2871776 31% /
tmpfs 1019341 1 1019340 1% /dev/shm
tmpfs 1019341 2 1019339 1% /run/lock
tmpfs 1024 17 1007 2% /sys/fs/cgroup
tmpfs 203868 65 203803 1% /run/user/1000
查看文件系统 inode 大小
sudo dumpe2fs /dev/sda1 | grep -i "inode size"
dumpe2fs 1.45.6 (20-Mar-2020)
Inode size: 256
查看文件系统 block 大小
$ sudo dumpe2fs /dev/sda1 | grep -i "block size"
dumpe2fs 1.45.6 (20-Mar-2020)
Block size: 4096
0x52 block
硬盘存储的最小单位是扇区（sector），每个扇区存储 512B。Linux 内核使用块（block）作为最小寻址单元，也就是说操作系统一次性会连续读取多个扇区，这些扇区组成了一个块。 block 的大小是 sector 的 2^n 次方倍（n 可以为 0），但是不大于 page size。常见的 block 大小为 512Bytes，1KB，4KB。
查看每个分区 block 数量
$ df -l /dev/sda1
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sda1 64806500 58404920 3079828 95% /
查看指定分区的扇区、磁道、柱面、磁头等信息，磁盘的容量=磁头*磁道*扇区(512B)*柱面
$ sudo fdisk -l /dev/sda1 1 ⨯
Disk /dev/sda1: 63.04 GiB, 67693969408 bytes, 132214784 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
总结
Linux 系统是一种典型的多用户操作系统，不同用户处于不同地位，拥有不同权限。为保护系统安全，不同用户对同一文件的访问权限做了不同规定。我们在这里讨论了常见的文件属性，也讲述其中的一些特殊权限。并结合一些实际案例（拥有写权限却不能写入文件）介绍 Linux 内核新特性。这都是由实际项目中发现的安全问题引发的一些思考。
参考文献
- Linux chmod命令
- linux权限补充：rwt rwT rws rwS 特殊权限
- El usuario root no puede escribir en un archivo en /tmp propiedad de otra persona en 20.04, pero sí en 18.04
- Los permisos de grupo para root no funcionan en /tmp
- https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1877151
- https://www.techopedia.com/definition/22339/sticky-bit
- https://en.wikipedia.org/wiki/Sticky_bit