Understanding Linux File Permissions: A Detailed Guide

$ ls -l
-rw-r--r-- 1 john developers 2048 Sep 21 12:34 myfile.txt```

Breaking down the output:
* `-rw-r--r--` represents the file permissions.

* `1` indicates the number of hard links.

* `john` is the owner of the file.

* `developers` is the group that has access to the file.

* `2048` is the file size (in bytes).

* `Sep 21 12:34` is the last modification date and time.

* `myfile.txt` is the name of the file.

#### Understanding the Permission Breakdown
* **First character** (`-`): This indicates the type of file. For a regular file, it’s `-`, for a directory it’s `d`.

* **Next three characters** (`rw-`): These show the permissions for the owner. In this case, the owner has read (r) and write (w) permissions, but not execute (x).

* **Next three characters** (`r--`): These represent the group permissions. Here, the group has read-only access.

* **Final three characters** (`r--`): These are the permissions for others (all other users), who also have read-only access.
Modifying File Permissions in Linux

Changing file permissions can be done using the `chmod` command. There are two methods to do this:
* **Symbolic Method**

* **Numeric Method**

#### 1. Symbolic Method

The symbolic method involves using letters to represent the permission categories and actions. Here's a breakdown of the syntax:
* `u` = owner

* `g` = group

* `o` = others

* `a` = all (owner, group, and others)
The symbols `+`, `-`, and `=` are used to add, remove, or set specific permissions.

For example:
```bash
chmod u+x myfile.txt```

This command adds execute permission (`+x`) for the owner (`u`) of the file `myfile.txt`.

You can also combine multiple permissions in one command:
```bash
chmod u+rwx,g+rx,o+r myfile.txt```

This adds read, write, and execute permissions for the owner, read and execute permissions for the group, and read permission for others.
#### 2. Numeric Method (Octal Notation)

The numeric method uses a three-digit code to represent the permissions. Each type of permission (read, write, execute) is assigned a value:
* Read = 4

* Write = 2

* Execute = 1
To set permissions, you sum the values for each user category (owner, group, others). For example:
* `7` (4+2+1) = read, write, and execute

* `6` (4+2) = read and write

* `5` (4+1) = read and execute

* `4` = read only
So, if you want to give the owner read, write, and execute permissions, the group read and execute permissions, and others only read permission, you would use:
```bash
chmod 755 myfile.txt```

Here’s how the octal numbers translate into permission sets:
* `7` = rwx (read, write, execute for the owner)

* `5` = r-x (read and execute for the group)

* `5` = r-x (read and execute for others)
Ownership and Groups: `chown` and `chgrp`

Besides changing file permissions, you can also change the ownership and group associated with a file using the `chown` and `chgrp` commands.
#### Changing File Ownership with `chown`

The `chown` command allows you to change the owner of a file. The syntax is:
```bash
chown newowner myfile.txt```

For example, to change the owner of `myfile.txt` to the user `jane`, you would use:
```bash
chown jane myfile.txt```
#### Changing Group Ownership with `chgrp`

If you want to change the group that owns the file, use the `chgrp` command:
```bash
chgrp newgroup myfile.txt```

For instance, to change the group ownership of `myfile.txt` to `staff`, use:
```bash
chgrp staff myfile.txt```

You can combine both `chown` and `chgrp` in one command:
```bash
chown jane:staff myfile.txt```

This changes the owner to `jane` and the group to `staff`.

Special Permissions: SUID, SGID, and Sticky Bit

Apart from the regular read, write, and execute permissions, Linux offers three special permissions:
* **SUID (Set User ID)**: When applied to an executable file, SUID allows users to execute the file with the permissions of the file’s owner. This is mostly used for system binaries like `passwd`.

* **SGID (Set Group ID)**: Similar to SUID but applies to groups. When applied to a directory, files created in that directory inherit the group ID of the directory rather than the user’s default group.

* **Sticky Bit**: This is commonly used on directories like `/tmp`. It ensures that only the owner of a file can delete or rename it, even if other users have write permissions for the directory.
To set these special permissions, use `chmod` with an extra digit in the numeric method:
* **SUID** = 4

* **SGID** = 2

* **Sticky Bit** = 1
For example, to set SUID, SGID, and Sticky Bit on a directory:
```bash
chmod 4755 mydirectory