document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2024-12-23 21:20:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

TSL

Browse Source
This commit is contained in:
Xingyu Wang 2019-11-07 22:33:45 +08:00
parent 74ff832d1d
commit c82b105b1b
2 changed files with 322 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

346
sources/tech/20190801 Linux permissions 101.md
View File

@ -1,346 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (wxy)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Linux permissions 101)
[#]: via: (https://opensource.com/article/19/8/linux-permissions-101)
[#]: author: (Alex Juarez https://opensource.com/users/mralexjuarezhttps://opensource.com/users/marcobravohttps://opensource.com/users/greg-p)
Linux permissions 101
======
Knowing how to control users' access to files is a fundamental system
administration skill.
![Penguins][1]
Understanding Linux permissions and how to control which users have access to files is a fundamental skill for systems administration.
This article will cover standard Linux file systems permissions, dig further into special permissions, and wrap up with an explanation of default permissions using **umask**.
### Understanding the ls command output
Before we can talk about how to modify permissions, we need to know how to view them. The **ls** command with the long listing argument (**-l**) gives us a lot of information about a file.
```
$ ls -lAh
total 20K
-rwxr-xr--+ 1 root root    0 Mar  4 19:39 file1
-rw-rw-rw-. 1 root root    0 Mar  4 19:39 file10
-rwxrwxr--+ 1 root root    0 Mar  4 19:39 file2
-rw-rw-rw-. 1 root root    0 Mar  4 19:39 file8
-rw-rw-rw-. 1 root root    0 Mar  4 19:39 file9
drwxrwxrwx. 2 root root 4.0K Mar  4 20:04 testdir
```
To understand what this means, let's break down the output regarding the permissions into individual sections. It will be easier to reference each section individually.
Take a look at each component of the final line in the output above:
```
`drwxrwxrwx. 2 root root 4.0K Mar  4 20:04 testdir`
```
Section 1 | Section 2 | Section 3 | Section 4 | Section 5 | Section 6 | Section 7
---|---|---|---|---|---|---
d | rwx | rwx | rwx | . | root | root
Section 1 (on the left) reveals what type of file it is.
d | Directory
---|---
- | Regular file
l | A soft link
The [info page][2] for **ls** has a full listing of the different file types.
Each file has three modes of access:
* the owner
* the group
* all others
Sections 2, 3, and 4 refer to the user, group, and "other users" permissions. And each section can include a combination of **r** (read), **w** (write), and **x** (executable) permissions.
Each of the permissions is also assigned a numerical value, which is important when talking about the octal representation of permissions.
Permission | Octal Value
---|---
Read | 4
Write | 2
Execute | 1
Section 5 details any alternative access methods, such as SELinux or File Access Control List (FACL).
Method | Character
---|---
No other method | -
SELinux | .
FACLs | +
Any combination of methods | +
Sections 6 and 7 are the names of the owner and the group, respectively.
### Using chown and chmod
#### The chown command
The **chown** (change ownership) command is used to change a file's user and group ownership.
To change both the user and group ownership of the file **foo** to **root**, we can use these commands:
```
$ chown root:root foo
$ chown root: foo
```
Running the command with the user followed by a colon (**:**) sets both the user and group ownership.
To set only the user ownership of the file **foo** to the **root** user, enter:
```
`$ chown root foo`
```
To change only the group ownership of the file **foo**, precede the group with a colon:
```
`$ chown :root foo`
```
#### The chmod command
The **chmod** (change mode) command controls file permissions for the owner, group, and all other users who are neither the owner nor part of the group associated with the file.
The **chmod** command can set permissions in both octal (e.g., 755, 644, etc.) and symbolic (e.g., u+rwx, g-rwx, o=rw) formatting.
Octal notation assigns 4 "points" to **read**, 2 to **write**, and 1 to **execute**. If we want to assign the user **read** permissions, we assign 4 to the first slot, but if we want to add **write** permissions, we must add 2. If we want to add **execute**, then we add 1. We do this for each permission type: owner, group, and others.
For example, if we want to assign **read**, **write**, and **execute** to the owner of the file, but only **read** and **execute** to group members and all other users, we would use 755 in octal formatting. That's all permission bits for the owner (4+2+1), but only a 4 and 1 for the group and others (4+1).
> The breakdown for that is: 4+2+1=7; 4+1=5; and 4+1=5.
If we wanted to assign **read** and **write** to the owner of the file but only **read** to members of the group and all other users, we could use **chmod** as follows:
```
`$ chmod 644 foo_file`
```
In the examples below, we use symbolic notation in different groupings. Note the letters **u**, **g**, and **o** represent **user**, **group**, and **other**. We use **u**, **g**, and **o** in conjunction with **+**, **-**, or **=** to add, remove, or set permission bits.
To add the **execute** bit to the ownership permission set:
```
`$ chmod u+x foo_file`
```
To remove **read**, **write**, and **execute** from members of the group:
```
`$ chmod g-rwx foo_file`
```
To set the ownership for all other users to **read** and **write**:
```
`$ chmod o=rw`
```
### The special bits: Set UID, set GID, and sticky bits
In addition to the standard permissions, there are a few special permission bits that have some useful benefits.
#### Set user ID (suid)
When **suid** is set on a file, an operation executes as the owner of the file, not the user running the file. A [good example][3] of this is the **passwd** command. It needs the **suid** bit to be set so that changing a password runs with root permissions.
```
$ ls -l /bin/passwd
-rwsr-xr-x. 1 root root 27832 Jun 10  2014 /bin/passwd
```
An example of setting the **suid** bit would be:
```
`$ chmod u+s /bin/foo_file_name`
```
#### Set group ID (sgid)
The **sgid** bit is similar to the **suid** bit in the sense that the operations are done under the group ownership of the directory instead of the user running the command.
An example of using **sgid** would be if multiple users are working out of the same directory, and every file created in the directory needs to have the same group permissions. The example below creates a directory called **collab_dir**, sets the **sgid** bit, and changes the group ownership to **webdev**.
```
$ mkdir collab_dir
$ chmod g+s collab_dir
$ chown :webdev collab_dir
```
Now any file created in the directory will have the group ownership of **webdev** instead of the user who created the file.
```
$ cd collab_dir
$ touch file-sgid
$ ls -lah file-sgid
-rw-r--r--. 1 root webdev 0 Jun 12 06:04 file-sgid
```
#### The "sticky" bit
The sticky bit denotes that only the owner of a file can delete the file, even if group permissions would otherwise allow it. This setting usually makes the most sense on a common or collaborative directory such as **/tmp**. In the example below, the **t** in the **execute** column of the **all others** permission set indicates that the sticky bit has been applied.
```
$ ls -ld /tmp
drwxrwxrwt. 8 root root 4096 Jun 12 06:07 /tmp/
```
Keep in mind this does not prevent somebody from editing the file; it just keeps them from deleting the contents of a directory.
We set the sticky bit with:
```
`$ chmod o+t foo_dir`
```
On your own, try setting the sticky bit on a directory and give it full group permissions so that multiple users can read, write and execute on the directory because they are in the same group.
From there, create files as each user and then try to delete them as the other.
If everything is configured correctly, one user should not be able to delete users from the other user.
Note that each of these bits can also be set in octal format with SUID=4, SGID=2, and Sticky=1.
```
$ chmod 4744
$ chmod 2644
$ chmod 1755
```
#### Uppercase or lowercase?
If you are setting the special bits and see an uppercase **S** or **T** instead of lowercase (as we've seen until this point), it is because the underlying execute bit is not present. To demonstrate, the following example creates a file with the sticky bit set. We can then add/remove the execute bit to demonstrate the case change.
```
$ touch file cap-ST-demo
$ chmod 1755 cap-ST-demo
$ ls -l cap-ST-demo
-rwxr-xr-t. 1 root root 0 Jun 12 06:16 cap-ST-demo
$ chmod o-x cap-X-demo
$ ls -l cap-X-demo
-rwxr-xr-T. 1 root root 0 Jun 12 06:16 cap-ST-demo
```
#### Setting the execute bit conditionally
To this point, we've set the **execute** bit using a lowercase **x**, which sets it without asking any questions. We have another option: using an uppercase **X** instead of lowercase will set the **execute** bit only if it is already present somewhere in the permission group. This can be a difficult concept to explain, but the demo below will help illustrate it. Notice here that after trying to add the **execute** bit to the group privileges, it is not applied.
```
$ touch cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+X cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
```
In this similar example, we add the execute bit first to the group permissions using the lowercase **x** and then use the uppercase **X** to add permissions for all other users. This time, the uppercase **X** sets the permissions.
```
$ touch cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+x cap-X-file
$ ls -l cap-X-file
-rw-r-xr--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+x cap-X-file
$ chmod o+X cap-X-file
ls -l cap-X-file
-rw-r-xr-x. 1 root root 0 Jun 12 06:31 cap-X-file
```
### Understanding umask
The **umask** masks (or "blocks off") bits from the default permission set in order to define permissions for a file or directory. For example, a 2 in the **umask** output indicates it is blocking the **write** bit from a file, at least by default.
Using the **umask** command without any arguments allows us to see the current **umask** setting. There are four columns: the first is reserved for the special suid, sgid, or sticky bit, and the remaining three represent the owner, group, and other permissions.
```
$ umask
0022
```
To understand what this means, we can execute **umask** with a **-S** (as shown below) to get the result of masking the bits. For instance, because of the **2** value in the third column, the **write** bit is masked off from the group and other sections; only **read** and **execute** can be assigned for those.
```
$ umask -S
u=rwx,g=rx,o=rx
```
To see what the default permission set is for files and directories, let's set our **umask** to all zeros. This means that we are not masking off any bits when we create a file.
```
$ umask 000
$ umask -S
u=rwx,g=rwx,o=rwx
$ touch file-umask-000
$ ls -l file-umask-000
-rw-rw-rw-. 1 root root 0 Jul 17 22:03 file-umask-000
```
Now when we create a file, we see the default permissions are **read** (4) and **write** (2) for all sections, which would equate to 666 in octal representation.
We can do the same for a directory and see its default permissions are 777. We need the **execute** bit on directories so we can traverse through them.
```
$ mkdir dir-umask-000
$ ls -ld dir-umask-000
drwxrwxrwx. 2 root root 4096 Jul 17 22:03 dir-umask-000/
```
### Conclusion
There are many other ways an administrator can control access to files on a system. These permissions are basic to Linux, and we can build upon these fundamental aspects. If your work takes you into FACLs or SELinux, you will see that they also build upon these first rules of file access.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/8/linux-permissions-101
作者：[Alex Juarez][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mralexjuarezhttps://opensource.com/users/marcobravohttps://opensource.com/users/greg-p
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/linux-penguins.png?itok=yKOpaJM_ (Penguins)
[2]: https://www.gnu.org/software/texinfo/manual/info-stnd/info-stnd.html
[3]: https://www.theurbanpenguin.com/using-a-simple-c-program-to-explain-the-suid-permission/

322
translated/tech/20190801 Linux permissions 101.md Normal file
View File

@ -0,0 +1,322 @@
[#]: collector: (lujun9972)
[#]: translator: (wxy)
[#]: reviewer: (wxy)
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Linux permissions 101)
[#]: via: (https://opensource.com/article/19/8/linux-permissions-101)
[#]: author: (Alex Juarez https://opensource.com/users/mralexjuarezhttps://opensource.com/users/marcobravohttps://opensource.com/users/greg-p)
全面介绍 Linux 权限
======
> 知道如何控制用户对文件的访问是一项基本的系统管理技能。
![Penguins][1]
了解 Linux 权限以及如何控制哪些用户可以访问文件是系统管理的一项基本技能。
本文将介绍标准 Linux 文件系统权限，并进一步研究特殊权限，以及使用 `umask` 解释默认权限的出处。
### 理解 ls 命令的输出
在讨论如何修改权限之前，我们需要知道如何查看权限。通过 `ls` 命令的长列表参数（`-l`）为我们提供了有关文件的许多信息。
```
$ ls -lAh
total 20K
-rwxr-xr--+ 1 root root    0 Mar  4 19:39 file1
-rw-rw-rw-. 1 root root    0 Mar  4 19:39 file10
-rwxrwxr--+ 1 root root    0 Mar  4 19:39 file2
-rw-rw-rw-. 1 root root    0 Mar  4 19:39 file8
-rw-rw-rw-. 1 root root    0 Mar  4 19:39 file9
drwxrwxrwx. 2 root root 4.0K Mar  4 20:04 testdir
```
为了理解这些是什么意思，让我们将关于权限的输出分解为各个部分。单独理解每个部分会更容易。
让我们看看在上面的输出中的最后一行的每个组件：
```
drwxrwxrwx. 2 root root 4.0K Mar  4 20:04 testdir
```
第 1 节 | 第 2 节 | 第 3 节 | 第 4 节 | 第 5 节 | 第 6 节 | 第 7 节
---|---|---|---|---|---|---
`d` | `rwx` | `rwx` | `rwx` | `.` | `root` | `root`
第 1 节（左侧）显示文件的类型。
符号 | 类型
---|---
`d` | 目录
`-` | 常规文件
`l` | 软链接
`ls` 的 [info 页面][2]完整列出了不同的文件类型。
每个文件都有三种访问方式：
* 属主
* 组
* 所有其他人
  
第 2、3 和 4 节涉及用户、组和“其他用户”权限。每个部分都可以包含 `r`（读）、`w`（写）和 `x`（可执行）权限的组合。
每个权限还分配了一个数值，这在以八进制表示形式讨论权限时很重要。
权限 | 八进制值
---|---
`r` | 4
`w` | 2
`x` | 1
第 5 节描述了其他访问方法，例如 SELinux 或文件访问控制列表（FACL）。
访问方法 | 字符
---|---
没有其它访问方法 | `-`
SELinux | `.`
FACL | `+`
各种方法的组合 | `+`
第 6 节和第 7 节分别是属主和组的名称。
### 使用 chown 和 chmod
#### chown 命令
`chown`（更改所有权）命令用于更改文件的用户和组的所有权。
要将文件 `foo` 的用户和组的所有权更改为 `root`，我们可以使用以下命令：
```
$ chown root:root foo
$ chown root: foo
```
在用户后跟冒号（`:`）运行该命令将同时设置用户和组所有权。
要仅将文件 `foo` 的用户所有权设置为 `root` 用户，请输入：
```
$ chown root foo
```
要仅更改文件 `foo` 的组所有权，请在组之前加冒号：
```
$ chown :root foo
```
#### chmod 命令
`chmod`（更改模式）命令控制属主、组以及既不是属主也不属于与文件关联的组的所有其他用户的文件许可权。
`chmod` 命令可以以八进制（例如 `755`、`644` 等）和符号（例如 `u+rwx`、`g-rwx`、`o=rw`）格式设置权限。
八进制表示法将 4 个“点”分配给“读取”，将 2 个“点”分配给“写入”，将 1 个点分配给“执行”。如果要给用户（属主）分配“读”权限，则将 4 分配给第一个插槽，但是如果要添加“写”权限，则必须添加 2。如果要添加“执行”，则要添加 1。我们对每种权限类型执行此操作：属主、组和其他。
例如，如果我们想将 “读取”、“写入”和“执行”分配给文件的属主，但仅将“读取”和“执行”分配给组成员和所有其他用户，则我们应使用 `755`（八进制格式）。这是属主的所有权限位（`4 + 2 + 1`），但组和其他权限的所有权限位只有 `4` 和 `1`（`4 + 1`）。
> 细分为：4+2+1=7，4+1=5 和 4+1=5。
如果我们想将“读取”和“写入”分配给文件的属主，而只将“读取”分配给组的成员和所有其他用户，则可以如下使用 `chmod`：
```
$ chmod 644 foo_file
```
在下面的示例中，我们在不同的分组中使用符号表示法。注意字母 `u`、`g` 和 `o` 分别代表“用户”（属主）、“组”和“其他”。我们将 `u`、`g` 和 `o` 与 `+`、`-` 或 `=` 结合使用来添加、删除或设置权限位。
要将“执行”位添加到所有权权限集中：
```
$ chmod u+x foo_file
```
要从组成员中删除“读取”、“写入”和“执行”：
```
$ chmod g-rwx foo_file
```
要将所有其他用户的所有权设置为“读取”和“写入”：
```
$ chmod o=rw
```
### 特殊位：设置 UID、设置 GID 和粘滞位
除了标准权限外，还有一些特殊的权限位，它们具有一些有用的好处。
#### 设置用户 ID（suid）
当在文件上设置 `suid` 时，将以文件的属主的身份而不是运行该文件的用户身份执行操作。一个[好例子][3]是 `passwd` 命令。它需要设置 `suid` 位，以便更改密码的操作具有 root 权限。
```
$ ls -l /bin/passwd
-rwsr-xr-x. 1 root root 27832 Jun 10  2014 /bin/passwd
```
设置 `suid` 位的示例：
```
$ chmod u+s /bin/foo_file_name
```
#### 设置组 ID（sgid）
`sgid` 位与 `suid` 位类似，因为操作是在目录的组所有权下完成的，而不是以运行命令的用户身份。
一个使用 `sgid` 的例子是，如果多个用户正在同一个目录中工作，并且目录中创建的每个文件都需要具有相同的组权限。下面的示例创建一个名为 `collab_dir` 的目录，设置 `sgid` 位，并将组所有权更改为 `webdev`。
```
$ mkdir collab_dir
$ chmod g+s collab_dir
$ chown :webdev collab_dir
```
现在，在该目录中创建的任何文件都将具有 `webdev` 的组所有权，而不是创建该文件的用户的组。
```
$ cd collab_dir
$ touch file-sgid
$ ls -lah file-sgid
-rw-r--r--. 1 root webdev 0 Jun 12 06:04 file-sgid
```
#### “粘滞”位
粘滞位表示只有文件所有者才能删除该文件，即使组权限也允许该文件可以删除。通常，在 `/tmp` 这样的通用或协作目录上，此设置最有意义。在下面的示例中，“所有其他人”权限集的“执行”列中的 `t` 表示已应用粘滞位。
```
$ ls -ld /tmp
drwxrwxrwt. 8 root root 4096 Jun 12 06:07 /tmp/
```
请记住，这不会阻止某个人编辑该文件，它只是阻止他们删除该目录的内容。
我们将粘滞位设置为：
```
$ chmod o+t foo_dir
```
你可以自己尝试在目录上设置粘滞位并赋予其完整的组权限，以便多个属于同一组的用户可以在目录上进行读取、写入和执行。
接着，以每个用户的身份创建文件，然后尝试以另一个用户的身份删除它们。
如果一切配置正确，则一个用户应该不能从另一用户那里删除文件。
请注意，这些位中的每个位也可以用八进制格式设置：SUID = 4、SGID = 2 和 粘滞位 = 1。（LCTT 译注：这里是四位八进制数字）
```
$ chmod 4744
$ chmod 2644
$ chmod 1755
```
#### 大写还是小写？
如果要设置特殊位并看到大写的 `S` 或 `T` 而不是小写的字符（如我们之前所见），那是因为不存在（对应的）底层的执行位。为了说明这一点，下面的示例创建一个设置了粘滞位的文件。然后，我们可以添加和删除执行位以演示大小写更改。
```
$ touch file cap-ST-demo
$ chmod 1755 cap-ST-demo
$ ls -l cap-ST-demo
-rwxr-xr-t. 1 root root 0 Jun 12 06:16 cap-ST-demo
$ chmod o-x cap-X-demo
$ ls -l cap-X-demo
-rwxr-xr-T. 1 root root 0 Jun 12 06:16 cap-ST-demo
```
#### 有条件地设置执行位
至此，我们使用小写的 `x` 设置了执行位，而无需询问任何问题即可对其进行设置。我们还有另一种选择：使用大写的 `X` 而不是小写的，它将仅在权限组中某个位置已经有执行位时才设置执行位。这可能是一个很难解释的概念，但是下面的演示将帮助说明它。请注意，在尝试将执行位添加到组特权之后，该位没有被设置上。
```
$ touch cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+X cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
```
在这个类似的例子中，我们首先使用小写的 `x` 将执行位添加到组权限，然后使用大写的 `X` 为所有其他用户添加权限。这次，大写的 `X`设置了该权限。
```
$ touch cap-X-file
$ ls -l cap-X-file
-rw-r--r--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod g+x cap-X-file
$ ls -l cap-X-file
-rw-r-xr--. 1 root root 0 Jun 12 06:31 cap-X-file
$ chmod o+X cap-X-file
ls -l cap-X-file
-rw-r-xr-x. 1 root root 0 Jun 12 06:31 cap-X-file
```
### 理解 umask
`umask 会屏蔽（或“阻止”）默认权限集中的位，以定义文件或目录的权限。例如，`umask`输出中的 `2` 表示它至少在默认情况下阻止了文件的写入位。
使用不带任何参数的 `umask` 命令可以使我们看到当前的 `umask` 设置。共有四列：第一列为特殊的`suid`、`sgid` 或粘滞位而保留，其余三列代表属主、组和其他人的权限。
```
$ umask
0022
```
为了理解这意味着什么，我们可以用 `-S` 标志来执行 `umask`（如下所示）以了解屏蔽位的结果。例如，由于第三列中的值为 `2`，因此将“写入”位从组和其他部分中屏蔽掉了；只能为它们分配“读取”和“执行”。
```
$ umask -S
u=rwx,g=rx,o=rx
```
要查看文件和目录的默认权限集是什么，让我们将 `umask` 设置为全零。这意味着我们在创建文件时不会掩盖任何位。
```
$ umask 000
$ umask -S
u=rwx,g=rwx,o=rwx
$ touch file-umask-000
$ ls -l file-umask-000
-rw-rw-rw-. 1 root root 0 Jul 17 22:03 file-umask-000
```
现在，当我们创建文件时，我们看到所有部分的默认权限分别为“读取”（`4`）和“写入”（`2`），相当于八进制表示 `666`。
我们可以对目录执行相同的操作，并看到其默认权限为 `777`。我们需要在目录上使用“执行”位，以便可以遍历它们。
```
$ mkdir dir-umask-000
$ ls -ld dir-umask-000
drwxrwxrwx. 2 root root 4096 Jul 17 22:03 dir-umask-000/
```
### 总结
管理员还有许多其他方法可以控制对系统文件的访问。这些权限是 Linux 的基本权限，我们可以在这些基础上进行构建。如果你的工作将你带入 FACL 或 SELinux，你会发现它们也建立在这些文件访问的首要规则之上。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/8/linux-permissions-101
作者：[Alex Juarez][a]
选题：[lujun9972][b]
译者：[wxy](https://github.com/wxy)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/mralexjuarezhttps://opensource.com/users/marcobravohttps://opensource.com/users/greg-p
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/linux-penguins.png?itok=yKOpaJM_ (Penguins)
[2]: https://www.gnu.org/software/texinfo/manual/info-stnd/info-stnd.html
[3]: https://www.theurbanpenguin.com/using-a-simple-c-program-to-explain-the-suid-permission/