# Linux Intermediate Part3

**whoami:** It shows the **current username.**

```bash
labex:project/ $ whoami
labex
```

**id:** Linus users are organize into groups. To see **which group you are belong to** we can use id command.

```bash
labex:project/ $ id
uid=5000(labex) gid=5000(labex) groups=5000(labex),27(sudo),121(ssl-cert),5002(public)

## root is the superuser and it's like the administrator of the system.
labex:project/ $ id root 
uid=0(root) gid=0(root) groups=0(root)
```

* `uid`: Your User ID (a unique numerical identifier).
    
* `gid`: Your primary Group ID.
    
* `groups`: All the groups you are a member of.
    

```bash
labex:project/ $ sudo apt update
Get:1 http://mirrors.cloud.aliyuncs.com/ubuntu jammy InRelease [270 kB]
Get:2 http://mirrors.cloud.aliyuncs.com/ubuntu jammy-updates InRelease [128 kB]
Get:3 http://mirrors.cloud.aliyuncs.com/ubuntu jammy-backports InRelease [127 kB]

## installing htop 
labex:project/ $ sudo apt install htop
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
```

* `sudo`: Stands for **"SuperUser DO."** It allows you to **execute commands with administrator privileges** (temporarily).
    
* `apt`: The tool for **installing and managing software.**
    
* `install`: Tells `apt` that we want to install a program.
    
* `htop`: The **specific program** we want to install. *(****htop*** *is like the dashboard which gives real time view of what is happening inside the system)*
    

**htop:** Once it is run, it will give the output like the below. q is to quit

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1759348168194/51920261-6f4a-4e62-a4ac-842867fcfb93.png align="center")

**touch:** This is for **creating** a new **empty file** and **update** the **timestamp** of existing file. See the below examples.

```bash
labex:project/ $ touch example.txt
labex:project/ $ ls
example.txt
```

Let’s read about the file information about permission and all.

```bash
labex:project/ $ ls -l example.txt
-rw-rw-r-- 1 labex labex 0 Oct  6 02:52 example.txt
```

* `-rw-rw-r--` represents the file permissions (we'll explore this more in Step 4). The first character indicates the file type ( `-` for a regular file, `d` for directory, etc.). The remaining characters represent read, write, and execute permissions for the owner, group, and others.
    
* The first `labex` is the current owner of the file. This is the username that owns the file.
    
* The second `labex` is the current group of the file. A group is a collection of users that can share permissions.
    
* `0` is the file size in bytes. Since the file is empty, its size is zero.
    
* `Jul 29 15:11` is the last modified date and time.
    
* `example.txt` is the file name.
    

**chown:** This command allows us to **change** both **user** and **group ownership** of a file. See the below example and explanation.

```bash
labex:project/ $ ls -l example.txt
-rw-rw-r-- 1 labex labex 0 Oct  6 02:52 example.txt
labex:project/ $ sudo chown root:root example.txt 
labex:project/ $ ls -l example.txt               
-rw-rw-r-- 1 root root 0 Oct  6 02:52 example.txt
```

* `sudo` runs the command with **root privileges.** You'll likely be prompted for your password. `chown` requires elevated privileges because it's a powerful command that can affect system security. Without `sudo`, you'll get a "Permission denied" error.
    
* `chown` is the command to change ownership.
    
* `root:root` specifies the new **owner** and **group** (both set to root). The syntax is `owner:group`.
    
* `example.txt` is the target file.
    

**chown -R:** This is to change the owndership and group ownership of a directory including the sub directory. See the below example.

```bash
labex:project/ $ cd new-dir 
labex:new-dir/ $ ls
file1.txt  subdir
labex:new-dir/ $ cd ..         
labex:project/ $ ls -lR new-dir
new-dir:
total 4
-rw-rw-r-- 1 labex labex 13 Oct  6 03:13 file1.txt
drwxrwxr-x 2 labex labex 23 Oct  6 03:14 subdir

new-dir/subdir:
total 4
-rw-rw-r-- 1 labex labex 13 Oct  6 03:14 file2.txt
labex:project/ $ sudo chown -R root:root new-dir
labex:project/ $ ls -lR new-dir                 
new-dir:
total 4
-rw-rw-r-- 1 root root 13 Oct  6 03:13 file1.txt
drwxrwxr-x 2 root root 23 Oct  6 03:14 subdir

new-dir/subdir:
total 4
-rw-rw-r-- 1 root root 13 Oct  6 03:14 file2.txt
```

**chmod 700:** This command is to **change the permission** of a file.

```bash
labex:project/ $ ls -l example.txt
-rw-rw-r-- 1 labex labex 0 Oct  6 03:20 example.txt
labex:project/ $ sudo chmod 700 example.txt 
labex:project/ $ ls -l example.txt         
-rwx------ 1 labex labex 0 Oct  6 03:20 example.txt
```

* `700` is a numeric representation of permissions:
    
    * The **first** digit (`7`) represents the **owner's permissions.**
        
    * The **second** digit (`0`) represents the **group's permissions.**
        
    * The **third** digit (`0`) represents the **others' permissions.**
        

Each digit is a number from 0 to 7, calculated by adding the values for read (4), write (2), and execute (1) permissions:

* `4`: **Read permission**
    
* `2`: **Write permission**
    
* `1`: **Execute permission**
    
* `0`: **No permission**
    

So, `7` **(first digit) gives the owner read (4), write (2), and execute (1) permissions:** 4+2+1=7  
`0` (second digit) gives the group no permissions (0+0+0=0).  
`0` (third digit) gives others no permissions (0+0+0=0).

Therefore, `700` means: Owner: read, write, execute. Group: none. Others: none.

**chomod -R:** Changing the **permission of a directory.**

```bash
labex:project/ $ mkdir ~/test-dir
labex:project/ $ chmod 700 ~/test-dir 
labex:project/ $ ls -ld ~/test-dir 
drwx------ 2 labex labex 6 Oct  6 03:26 /home/labex/test-dir
labex:project/ $ chmod -R 755 ~/test-dir 
labex:project/ $ ls -ld ~/test-dir      
drwxr-xr-x 2 labex labex 6 Oct  6 03:26 /home/labex/test-dir
```

* `-R` applies the change **recursively to all files and subdirectories** (though our directory is empty in this case). It's good practice to include it when dealing with directories, even if they're currently empty, in case you add files later.
    
* `755` **gives read, write, and execute permissions to the owner, and read and execute permissions to group and others.**
    

Let's break down `755`:

* **Owner** (7): Read (4) + Write (2) + Execute (1) = 7
    
* **Group** (5): Read (4) + Execute (1) = 5
    
* **Others** (5): Read (4) + Execute (1) = 5
    

```bash
labex:project/ $ echo '#!/bin/bash\necho "Hello, World"' > script.sh
labex:project/ $ ls -l script.sh 
-rw-rw-r-- 1 labex labex 32 Oct  6 03:34 script.sh
labex:project/ $ ./script.sh 
zsh: permission denied: ./script.sh
# The permission is denied becase the user/owner doesn't have the 'execute'(x) permission.

## Now the below command will give the user(owner) the execute permission.
labex:project/ $ chmod u+x script.sh 
labex:project/ $ ls -l script.sh    
-rwxrw-r-- 1 labex labex 32 Oct  6 03:34 script.sh
labex:project/ $ ./script.sh                                        
Hello, World
```

* It creates a new file named [`script.sh`](http://script.sh). The `.sh` extension is commonly used for shell scripts. shell scripts are executable files that contain a series of commands that are executed in sequence.
    
* It writes two lines into this file:
    
    * `#!/bin/bash` (called a shebang) tells the system this is a bash script. The shebang line specifies the interpreter that should be used to execute the script. In this case, it's `/bin/bash`, which is the path to the Bash interpreter.
        
    * `echo "Hello, World"` is a command that will print "Hello, World" when the script runs. The `echo` command simply displays the text that follows it.
        
    * `\n` is a newline character, ensuring the commands are on separate lines in the file.
        

* `u` refers to the user (owner). Other options are `g` for group, `o` for others, and `a` for all (user, group, and others).
    
* `+x` adds execute permission. The `+` symbol adds a permission, while the `-` symbol removes a permission.
    

So, `u+x` means "add execute permission for the owner."

**useradd:** This is to create a new user.

* `sudo` is a command that gives you temporary superuser (administrator) privileges. We use it because creating a new user requires these higher-level permissions.
    
* `useradd` is the command to create a new user.
    
* `joker` is the username we're creating.
    

**Note:** By using **sudo**, we can **temporarily elevate our privilage** to perform administrative task.

```bash
labex:project/ $ sudo useradd joker
labex:project/ $ sudo grep -w 'joker' /etc/passwd
joker:x:5001:5001::/home/joker:/bin/sh
```

* Username: joker
    
* Password: x (the actual password is stored securely elsewhere)
    
* User ID: 5001
    
* Group ID: 5001
    
* Home Directory: `/home/joker`, but it hasn't been created yet
    
* Default Shell: `/bin/sh`
    

**useradd -m:** This option tells the system to create a home directory for the user. A home directory is like a personal folder where user can store their files and settings. Below command shows user bob is created with home directory.

```bash
labex:project/ $ sudo useradd -m bob
labex:project/ $ sudo ls -ld /home/bob 
drwxr-x--- 2 bob bob 57 Oct  8 03:08 /home/bob
```

* `d` at the start means it's a **directory**
    
* `rwxr-x---` shows who can read, write, or execute in this directory
    
* The two `bob` entries show that **both the user and group owner** of this directory is bob
    
* `57` is the **size of the directory** in bytes
    
* `Jan 19 13:33` is when the directory was created
    
* `/home/bob` is the location of the directory
    

**passwd**: This to set the **password** for the **user**. 1st it will ask for new password then retype it. **It will not show while typing.**

```bash
labex:project/ $ sudo passwd joker
New password: 
Retype new password: 
passwd: password updated successfully
```

**Note:** Linux store the encrypted passwords in a secured file called `/etc/shadow`. This is more secure than storing them in the `/etc/password` file where anyone can see them.

**usermod:** This is to modify the **user account settings.**

```bash
labex:project/ $ sudo usermod -d /home/wayne joker
labex:project/ $ sudo grep -w 'joker' /etc/passwd
joker:x:5001:5001::/home/wayne:/bin/sh

## we can change the user account default shell. See the below example.
labex:project/ $ sudo usermod -s /bin/bash joker
labex:project/ $ sudo grep -w 'joker' /etc/passwd
joker:x:5001:5001::/home/wayne:/bin/bash

## Adding user to the sudo group
```

**Adding user to a group:** In the below example we are adding the user joker to the sudo group. After the command is executed, the user doesn’t need to add sudo in his/her command for administrative task such as installing/removing software, change configuration file etc.

```bash
labex:project/ $ sudo usermod -s /bin/bash joker
labex:project/ $ sudo grep -w 'joker' /etc/passwd
joker:x:5001:5001::/home/wayne:/bin/bash

## verify that the user is added to the sudo group
labex:project/ $ groups joker
joker : joker sudo
```

* `usermod` is the command to modify user accounts
    
* `-aG` means "append to Group" (add to a group without removing from other groups)
    
* `sudo` is the group we're adding the user to
    
* `joker` is the user we're modifying
    

```bash
## The below command is to lock the user account using passwd -l

joker@68e562760f92ec70f1309fa2:~$ sudo passwd -l joker
passwd: password expiry information changed.

## See the result
joker@68e562760f92ec70f1309fa2:~$ su - joker
Password: 
su: Authentication failure

## passwd -u is to unlock the user account
joker@68e562760f92ec70f1309fa2:~$ sudo passwd -u joker
passwd: password expiry information changed.
joker@68e562760f92ec70f1309fa2:~$ su - joker
Password: 
To run a command as administrator (user "root"), use "sudo <command>".
See "man sudo_root" for details.
```

Delete the user: To delete the user and its home directory we use userdel -r.

```bash
sudo userdel -r bob
```