Kali Linux Penetration Testing Bible

Introduction

Kali is a popular Linux distribution used by security professionals and is becoming an important tool for daily use and for certifications. Penetration testers need to master Kali's hundreds of tools for pentesting, digital forensics, and reverse engineering. Kali Linux Penetration Testing Bible is a hands‐on guide for getting the most from Kali Linux for pentesting. This book is for working cybersecurity professionals in offensive, hands‐on roles, including red teamers, white‐hat hackers, and ethical hackers. Defensive specialists will also find this book valuable, as they need to be familiar with the tools used by attackers.

This comprehensive pentesting book covers every aspect of the art and science of penetration testing. It covers topics like building a modern Dockerized environment, the basics of bash language in Linux, finding vulnerabilities in different ways, identifying false positives, and practical penetration testing workflows. You'll also learn to automate penetration testing with Python and dive into advanced subjects like buffer overflow, privilege escalation, and beyond.

By reading this book, you will:

Gain a thorough understanding of the hundreds of penetration testing tools available in Kali Linux.

Master the entire range of techniques for ethical hacking so you can be more effective in your job and gain coveted certifications.

Learn how penetration testing works in practice and fill the gaps in your knowledge to become a pentesting expert.

Discover the tools and techniques that hackers use so you can boost your network's defenses.

What Does This Book Cover?

This book goes deep into the subject of penetration testing. For established penetration testers, this book fills all the practical gaps, so you have one complete resource that will help you as your career progresses. For newcomers to the field, Kali Linux Penetration Testing Bible is your best guide to how ethical hacking really works.

Chapter 1: Mastering the Terminal Window

This chapter outlines the in and outs of the Linux system Terminal window and covers how to manage the file system like the pros. You will learn how to manage users and groups inside Kali, and you will see how to manipulate files and folders during your engagements and much more.

Chapter 2: Bash Scripting

Bash scripting is an essential skill for a penetration tester. In this chapter you will learn how to start to use programming principles such as variables, functions, conditions, loops, and much more.

Chapter 3: Network Hosts Scanning

This chapter teaches you how to conduct network scans like professionals. You will learn first about the basics of networking, and then you will delve deep into the port scanning techniques.

Chapter 4: Internet Information Gathering

This chapter discusses the passive information gathering phase in penetration testing. You will be introduced to how to deal with advanced search engine queries. Also, you will learn how to use Shodan and other tools to get the job done.

Chapter 5: Social Engineering Attacks

This chapter focuses on how to take advantage of human weakness to exploit organizations. You will learn about how to send phishing emails and steal credentials. On top of that, you will see how to use the Social Engineer Toolkit as a penetration tester. Finally, you will see how USB Rubber Ducky operates in similar SE attacks.

Chapter 6: Advanced Enumeration Phase

This chapter reviews how to handle the enumeration phase in a penetration testing engagement. Enumeration means collecting the necessary information that will allow us to exploit the specific service (e.g., FTP, SSH, etc.).

Chapter 7: Exploitation Phase

This chapter discusses some actual attacks and shows you how to get inside the systems. In the previous chapters, you had all the information about each service, and in this one, we will take this step further and exploit the vulnerabilities.

Chapter 8: Web Application Vulnerabilities

This chapter focuses on the basics of web application vulnerabilities. The goal is to allow you test web applications with ease during your engagements. Every company has a website these days, and it's crucial to understand this topic from A to Z.

Chapter 9: Web Penetration Testing and Secure Software Development Lifecycle

In this chapter, you will mainly learn about the methodology of web application penetration testing and how to use Burp Suite Pro. Finally, you will see how to implement a secure software development lifecycle (SSDLC) in an organization.

Chapter 10: Linux Privilege Escalation

This chapter focuses mainly on Linux operating system privilege escalation. The techniques in this chapter will allow you to gain root privileges on a compromised Linux OS.

Chapter 11: Windows Privilege Escalation

This chapter describes how to get administrator privileges on the compromised Windows OS. First you will learn about how to enumerate the Windows OS, and then you will see how to exploit the Windows system with practical examples.

Chapter 12: Pivoting and Lateral Movement

This chapter describes how to use the pivoting techniques to move laterally on the compromised network. In this chapter, you will learn how Windows hashes work under the hood and how to reuse admin credentials to get the job done.

Chapter 13: Cryptography and Hash Cracking

This chapter describes how to crack hashes during your engagements using Hashcat. Before starting on the cracking topic, you will learn about the basics of cryptography including hashing and encryption.

Chapter 14: Reporting

This chapter explains how to present professional penetration testing reports. Also, you will learn how to evaluate accurately the severity of your findings.

Chapter 15: Assembly Language and Reverse Engineering

This chapter will introduce you to the concept of reverse engineering using the assembly language. You will learn about the basics of the assembly language including registers, assembly instructions, memory segments, and much more.

Chapter 16: Buffer/Stack Overflow

This chapter will use what you learned in the previous chapter to exploit the stack using the buffer overflow technique.

Chapter 17: Programming with Python

This chapter discusses the basics of Python version 3. This programming language is the choice of hackers, so you should learn it too.

Chapter 18: Pentest Automation with Python

This chapter focuses on the automation of the penetration testing phases using the Python language. You will see a complete practical example that can use in your career.

Appendix A: Kali Linux Desktop at a Glance

This appendix focuses on how to manage the interface of the Kali Linux desktop environment. You will learn how to handle this operating system with ease and customize it to your liking.

Appendix B: Building a Lab Environment Using Docker

This appendix will delve deep with Docker, and you will see how images and containers work in practice. Both Docker and hypervisor technologies facilitate the creation of a live lab so we, penetration testers, can have fun with it.

Companion Download Files

As you work through the examples in this book, you may choose either to type in all the code manually or to use the source code files that accompany the book. All the source code used in this book is available for download from www.wiley.com/go/kalilinuxpenbible .

How to Contact the Publisher

If you believe you've found a mistake in this book, please bring it to our attention. At John Wiley & Sons, we understand how important it is to provide our customers with accurate content, but even with our best efforts an error may occur.

To submit your possible errata, please email it to our Customer Service Team at [email protected] with the subject line Possible Book Errata Submission.

How to Contact the Author

We appreciate your input and questions about this book! Email the author at [email protected] , or message him on Twitter at @GusKhawaja .

CHAPTER 1

Mastering the Terminal Window

Kali Linux can be summarized in two simple words: terminal window. If you master your terminal window skills, then you will be one of those elite ethical hackers. In this chapter, you will learn all the essentials of the terminal window so you can start using Kali Linux like a boss.

If you already know how to manage the terminal window, please use this chapter as a reference, or maybe go over it quickly in case there is something new that you haven't learned before. The main goal of this chapter is not only to show you the commands of Kali Linux but to help you deeply understand it through practical examples.

Kali Linux is a Debian‐based operating system developed by Offensive Security, so if you're used to Ubuntu, for example, the commands in the terminal window will look the same since Debian and Kali share an equal distribution.

Here's what this chapter covers:

Kali Linux file system

Terminal window basics

Managing users and groups

Manipulating files and folders

Handling remote connections

Kali Linux system management

Dealing with networking in Kali Linux

Kali Linux File System

Understanding the structure of the file system in Kali Linux is crucial. The directory structure of your Kali OS is based on the Unix Filesystem Hierarchy Standard (FHS), and that's how the directories are structured inside Kali Linux. In Windows, the root directory is C:\ , but in Kali Linux, it's a forward slash ( / ). Do not confuse the term root directory with the root user's home directory, which is /root , because they are two different things; the latter is the home directory for the root user. Speaking about the root user, it's essential to understand that this user is the equivalent to the Administrator user on Windows operating systems. In the Kali 2020.1 release, Offensive Security introduced the nonroot user by default, which means that you'll need to execute the sudo command if you want to run high‐privilege tools.

To get a visual representation of the Kali Linux file system directories, open the terminal window and execute the ls command to list the contents of the root system directory. Take note that by default you will be in the user home directory. To change it, you must execute the cd / command:

kali@kali:~$ cd / kali@kali:/$ ls bin boot dev etc home initrd.img initrd.img.old lib lib32 lib64 libx32 lost+found media mnt opt proc root run sbin srv sys tmp usr var vmlinuz vmlinuz.old

/bin (binaries): This directory holds Linux binaries like the ls command that we executed earlier.

/sbin (system binaries): This directory contains system binary files that serve as administrative commands (e.g., fdisk ).

/ boot : This directory contains the Linux bootloader files.

/ dev (devices): This directory contains the device configuration files (e.g., /dev/null ).

/ sys : This is similar to /dev , which contains configurations about devices and drivers.

/ etc (etcetera): This directory contains all the administration system files (e.g., /etc/passwd shows all the system users in Kali).

/ lib (libraries): This directory contains the shared libraries for the binaries inside /bin and /sbin .

/ proc (processes): This directory holds the processes and kernel information files.

/ lost+found : As the name says, this directory contains the files that have been recovered.

/ mnt (mount): This directory contains the mounted directories (e.g., a remote file share).

/ media : This directory holds the removable media mounted directories (e.g., DVD).

/ opt (option): This directory is used for add‐on software package installation. Also, it is used when installing software by users (e.g., hacking tools that you download from GitHub).

/ tmp (temporary): This is a temporary folder used temporarily; the contents are wiped after each reboot. The tmp folder is a good place to download your tools for privilege escalation once you get a limited shell.

/ usr (user): This directory contains many subdirectories. In fact, /usr/share is a folder that you need to memorize because most of the tools that you use in Kali Linux (e.g., Nmap, Metasploit, etc.) are stored there, and it contains the wordlists dictionary files ( /usr/share/wordlists/ ).

/ home : This is the home for Kali Linux users (e.g., /home/john/ ).

/ root : This is the root user home directory.

/ srv (serve): This folder holds some data related to system server functionalities (e.g., data for FTP servers).

/ var (variable): This folder holds variable data for databases, logs, and websites. For example, /var/www/html/ contains the files for the Apache web server.

/ run (runtime): This directory contains runtime system data (e.g., currently logged‐in users).

Terminal Window Basic Commands

There are lots of common commands that we use as penetration testers on a daily basis. Many of these commands will be listed in the upcoming sections or later in this book. In this section, you will see all the general standard tools that I personally use frequently. You will also learn the basic commands that are identified for general use.

First, to open the terminal window from the desktop, you can use the Ctrl+Alt+T key combination instead of opening the application from its icon using the mouse cursor.

If you want to get help for any command that you want to execute, just append ‐h or ‐ ‐ help to it (some commands require you to use only one of them). For example, if you want to see the different options for the cat command, just type cat ‐‐help in your terminal window to get all the help needed regarding this tool. In the next command ( cat ‐h ), you'll see that the ‐h option does not work for the cat command. Instead, I used the ‐ ‐help option. (The cat command is used frequently to display the contents of a text file in the terminal window.)

kali@kali:~$ cat -h cat: invalid option -- 'h' Try 'cat --help' for more information. kali@kali:~$ cat --help Usage: cat [OPTION]… [FILE]… Concatenate FILE(s) to standard output. With no FILE, or when FILE is -, read standard input. -A, --show-all          equivalent to -vET -b, --number-nonblank    number nonempty output lines, overrides -n -e                      equivalent to -vE -E, --show-ends          display $ at end of each line -n, --number            number all output lines -s, --squeeze-blank      suppress repeated empty output lines -t                      equivalent to -vT -T, --show-tabs          display TAB characters as ^I -u                      (ignored) -v, --show-nonprinting  use ^ and M- notation, except for LFD and TAB     --help    display this help and exit     --version output version information and exit Examples: cat f - g  Output f's contents, then standard input, then g's contents. cat        Copy standard input to standard output. GNU coreutils online help: Full documentation at: or available locally via: info '(coreutils) cat invocation'

To clear the terminal window text, execute the clear command or press Ctrl+L to get the job done.

To open a new terminal window tab, from your current terminal session press Ctrl+Shift+T.

To complete the input (e.g., a filename or a command name) automatically, I use the Tab key. What if multiple files start with the same text? Then, if you hit Tab twice, the terminal window will display all the options in place. (The best way to understand this chapter is to open the terminal window and practice while reading the instructions.)

Let's look at an example. In my home directory, I have two files, test.sh and test.txt . Once I start typing cat tes , I hit Tab once, and it shows me cat test. . This means I have multiple files with the same name. Then I hit Tab twice, and it shows me the list of files in the current directory. Finally, I can open the desired file, which is test.txt :

root@kali:~# cat test. Test.sh      test.txt root@kali:~ cat test.txt test

To stop the execution of any tool while it's running, you can use the Ctrl+C shortcut to stop it.

To exit the terminal window and close it, use the exit command or press Ctrl+D to get the job done.

To restart Kali Linux from the terminal window, you must use the reboot command, and to shut it down, you must use the poweroff command.

Now, to get the list of executed recent commands, you'll have to use the history command.

In Linux, you must understand that we use a lot of redirection in the terminal window. For example, to save the output of the ls command into a file, I can redirect the output from the terminal window to a text file using the > (greater than) character:

kali@kali:~$ ls> ls_file.txt kali@kali:~$ cat ls_file.txt Desktop Documents Downloads ls_file.txt Music Pictures Public Templates Videos

Now, you can do the opposite by redirecting (printing) the text file contents into the terminal window using the < (less than) character:

kali@kali:~$ cat < ls_file.txt Desktop Documents Downloads ls_file.txt Music Pictures Public Templates Videos

Another redirection that you need to be aware of is the commands pipe. In summary, you can combine the output of each command and send it to the next one using the | character:

$command 1 | command2 | command3 …

For example, I will read a file, then sort the results, and finally use the grep command to filter out some text strings (the goal is to extract the files that start with the word test):

kali@kali:~$ cat ls_file.txt | sort | grep test test.sh test.txt

Tmux Terminal Window

Tmux is a particular terminal window that allows you to manage multiple windows in your current terminal session. The best way to explain it is through examples.

Starting Tmux

To start Tmux, you just type Tmux in your terminal window. At the bottom of your terminal window, you'll notice that a number and a name have been assigned to your opened window tab, as shown in Figure 1.1.

Figure 1.1 Tmux New Window

So what? Let's say you're in an engagement and you want to run Nmap in one window, plus run Metasploit in another one, and so on. This is where Tmux is handy, because you can work on multiple windows/sessions at the same time.

Tmux Key Bindings

In Tmux, you must use Ctrl+B to instruct it that you want to execute a Tmux action (command). In fact, the key combination Ctrl+B is the default one. You can always change the default configurations of Tmux in the configuration file. To change this behavior and assign Ctrl+A instead of Ctrl+B, then you must create the config file yourself for the first time. To get the job done, you have two options for creating a config file in Tmux. The first way is to add a user‐specific file called ~/.tmux.conf , and the second way is to add a global file (to all users) under /etc/tmux.conf . In my case (for this example), I will add the configuration file under /etc/tmux.conf (and I will add the configurations for the key bindings in it):

root@kali:/# touch /etc/tmux.conf root@kali:/# echo unbind C-b>> /etc/tmux.conf root@kali:/# echo set -g prefix C-a>> /etc/tmux.conf root@kali:/# echo bind C-a send-prefix>> /etc/tmux.conf

Tmux Session Management

In Figure 1.1, you can see that the name bash has been assigned automatically to your current session.

Window Rename

To rename the session, press Ctrl+B first (or Ctrl+A if you made the changes in the config files that we did previously). Then remove your fingers from the keyboard and press the comma (,) key on your keyboard. You should see that the prompt has changed to allow you to rename it. I will call it Window1; then press Enter after finishing the task:

(rename-window) Window1

Window Creation

At this stage, we have only one window, so let's create a second one by pressing Ctrl+B and then pressing the C key. Looking at the bottom, you'll see you have a new bash window, and Tmux has already highlighted the current tab with an asterisk (*), as shown in Figure 1.2.

Figure 1.2 New Tmux Highlighted Tab

Splitting Windows

To split the selected tab into two subwindows side by side, as shown in Figure 1.3, you must press Ctrl+B and then enter the % character on your keyboard (remember that you need to press Shift+% or else it will be considered 5 on your keyboard).

Figure 1.3 Tmux Vertical Windows Side by Side

Navigating Inside Tmux

Amazing, right? As you can see, the cursor is on the right pane (see Figure 1.3). To switch between panes (subwindows), press Ctrl+B and use the arrow keys on your keyboard (to change left, right, up, and bottom).

Next, go back to the Window1 session. To switch between windows, press Ctrl+B and then the number of the window (which is 0 according to this example), and we should be back to the first window.

Now, divide the window into two sections, one over the other, as shown in Figure 1.4. To get this done, use Ctrl+B and then the double quote (). Remember that you need to press Shift+ or else that key produces a single quote.

Figure 1.4 Tmux Horizontal Windows

The final tip for managing Tmux is for scrolling up and down inside a window or a pane session. In fact, you can't use your mouse to scroll up and down in a Tmux session (the mouse scrolling is for commands history). Instead, you need to press Ctrl+B and then [ on your keyboard, and after that you can use the up and down arrow keys on your keyboard to scroll. Once you're done with the scrolling, press Esc or the Q key on your keyboard to go back to the normal mode.

To close a pane or a window, just use exit like with any regular terminal window session.

Tmux Commands Reference

Table 1.1 summarizes all the Tmux commands that you learned in this section. You can use it as a reference (this is just a quick guide so you can start using Tmux; if you want to go beyond basics, check the manual reference).

Table 1.1 Tmux Keyboard Shortcuts

Managing Users and Groups in Kali

Understanding the commands for managing users and groups is important because you'll use the information when you learn about privilege escalation later in the book. All the commands in this chapter will help you a lot in your engagements while using Kali Linux (as an OS for your pentests).

Figure 1.5 summarizes all the commands related to users' management/security in Kali Linux.

Users Commands

Low‐privilege users must prepend commands with sudo to execute system commands (and the low‐privilege user must be in the sudo group to execute sudo ). You will be asked for your account password if you want to use the sudo command. For example, if you want to execute the fdisk system tool to show the Kali‐attached devices, use the following command:

root@kali:~# fdisk -l Disk /dev/sda: 80 GiB, 85899345920 bytes, 167772160 sectors Disk model: VMware Virtual S Units: sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disklabel type: dos Disk identifier: 0x7c02676c Device    Boot    Start  End  Sectors Size Id Type /dev/sda1  *      2048 165771263 165769216 79G 83 Linux /dev/sda2          165773310 167770111 1996802 975M 5 Extended /dev/sda5          165773312 167770111 1996800 975M 82 Linux swap / Solaris

Figure 1.5 Kali Linux OS Security Commands

To add a new user to Kali (in this example, Gus is going to be the user), use the useradd command. Along with it you need to choose the sudo group with the ‐G option and the shell type with the ‐s option:

$useradd -m [user name] -G [group name] -s [shell type]

For our example, it looks like this:

root@kali:~# useradd -m Gus -G sudo -s /bin/bash

Next, let's give the new user a password using the passwd command:

$passwd [user name - that you want to change password]

Here's how it looks in the terminal window:

root@kali:~# passwd Gus New password: Retype new password: passwd: password updated successfully

If you look closely at the top left, it's written root@kali ; I know that this is confusing, but the structure of this part is in the following format:

username@hostname

To switch to the new user Gus that we created previously, we use the su command (pay attention to how the user has changed in the terminal window text and turned into Gus@kali ):

$su [user name – that you want to switch to] root@kali:~# su Gus Gus@kali:/root$

To learn the capabilities of the current user with the sudo command, you need to execute sudo ‐l to get the correct information:

Gus@kali:~$ sudo -l We trust you have received the usual lecture from the local System Administrator. It usually boils down to these three things: #1) Respect the privacy of others. #2) Think before you type. #3) With great power comes great responsibility. [sudo] password for Gus: Matching Defaults entries for Gus on kali:   env_reset, mail_badpass,   secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin User Gus may run the following commands on kali:     (ALL : ALL) ALL

To view the current user information, use the id command:

Gus@kali:~$ id uid=1001(Gus) gid=1001(Gus) groups=1001(Gus),27(sudo)

To list the currently logged on users, use w or who (with fewer details):

Gus@kali:~$ w 10:44:06 up 19 min, 1 user, load average: 0.00, 0.00, 0.00 USER      TTY    FROM    LOGIN@  IDLE    JCPU    PCPU    WHAT root      tty7    :0      10:24  19:55  2.36s  2.36s  /usr/lib/x Gus@kali:~$ who root      tty7    2020-09-22 10:24 (:0)

To remove a user (the user that we will remove in this example is test ), execute the userdel command:

$userdel [user name – that you want to delete] Gus@kali:~$ sudo userdel test

To list the last logged in users in the Kali system, use the last command:

Gus@kali:~$ last root      tty7        :0              Tue Sep 22 10:24  still logged in reboot    system boot  5.7.0-kali1-amd6 Tue Sep 22 10:24  still running root      tty8        :1              Tue Sep 22 10:21 - 10:23 (00:02) kali      pts/1        tmux(1793).%0    Mon Sep 21 12:16 - 10:23 (22:07) kali      pts/2        tmux(1584).%0    Mon Sep 21 11:48 - 11:48 (00:00) kali      tty7        :0              Mon Sep 21 10:50 - 10:23 (23:33) reboot    system boot  5.7.0-kali1-amd6 Mon Sep 21 10:50 - 10:23 (23:33) kali      tty7        :0              Mon Jul 27 13:36 - 15:56 (02:20) reboot    system boot  5.7.0-kali1-amd6 Mon Jul 27 13:36 - 15:57 (02:20) kali      tty7        :0              Mon Jul 27 13:31 - crash (00:05) reboot    system boot  5.7.0-kali1-amd6 Mon Jul 27 13:30 - 15:57 (02:26) kali      tty7        :0              Mon Jul 27 13:28 - crash (00:02) reboot    system boot  5.7.0-kali1-amd6 Mon Jul 27 13:28 - 15:57 (02:28) wtmp begins Mon Jul 27 13:28:09 2020

Finally, take note that all the users in Kali are stored in a configuration file, /etc/passwd . Use the cat command to reveal its contents:

Gus@kali:~$ cat /etc/passwd root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin bin:x:2:2:bin:/bin:/usr/sbin/nologin

The previous command will list all the users, even the system ones (the example just shows the first three). To filter the contents and limit the results for the human users, pipe the output using | in the grep command:

Gus@kali:~$ cat /etc/passwd | grep /bin/bash root:x:0:0:root:/root:/bin/bash postgres:x:119:124:PostgreSQL administrator,,,:/var/lib/postgresql:/bin/bash kali:x:1000:1000:kali,,,:/home/kali:/bin/bash Gus:x:1001:1001::/home/Gus:/bin/bash

Groups Commands

To add a new group in Kali Linux, use the groupadd command:

$groupadd [new group name] Gus@kali:~$ sudo groupadd hackers

To join a user (which is Gus for this example) to the hackers group that we created earlier, execute the usermod command:

$usermod -aG [group name] [user name] Gus@kali:~$ sudo usermod -aG hackers Gus

To list all the groups created in Kali Linux, open the file /etc/group . Again, use the cat command to get the job done (the following example shows only the first three):

Gus@kali:~$ cat /etc/group root:x:0: daemon:x:1: bin:x:2: […] hackers:x:1002:Gus

Managing Passwords in Kali

You probably want your root user back like in the old days. To get this account back, you will need to set its password first. To change a user password, you have to use the passwd command:

Gus@kali:~$ sudo passwd root New password: Retype new password: passwd: password updated successfully

Now to use the powerful root account, you have to use the su command to switch user:

Gus@kali:~$ sudo su root root@kali:/home/Gus#

From now on, on the login screen, you can choose your root account instead of your nonroot user.

Finally, to list all the user's credentials in Kali Linux, you can reveal them in the file /etc/shadow . Use the grep command to get the user credentials for Gus:

root@kali:/# cat /etc/shadow | grep Gus Gus:$6$Hb.QBfIoaCBTiqK$EUJ4ZdWmbsFqHMsPbMEz2df6FtWVf4J/tMulxCoLQmfMlVWyqpMUHBGmHFulRknYHgSrFIF.hQTANgzJ6CQM8/:18527:0:99999:7:::

Let's simplify what you need to understand from the string. The delimiter that separates each section is the colon character (:).

Second, the $6$ means that the password is hashed using SHA‐512. Finally, the hashed password starts after $6$ and right before the : delimiter:

Hb.QBfIoaCBTiqK$EUJ4ZdWmbsFqHMsPbMEz2df6FtWVf4J/tMulxCoLQmfMlVWyqpMUHBGmHFulRknYHgSrFIF.hQTANgzJ6CQM8/

Files and Folders Management in Kali Linux

Your next challenge in the Linux operating system is to learn how to manage files and folders. By the end of this section, you will start using the files and directories on Kali like the pros.

Displaying Files and Folders

To list the files and subfolders inside any directory, use the ls command to get the job done (I use it a lot to get simpler output). But sometimes, the ls command by itself is not enough, so you may need to add a couple of options to get better output clarity. The first option that you can use is the ‐a command (all contents including hidden files), and the second option is the ‐l command (formatted list):

root@kali:~# ls Desktop Documents Downloads Music Pictures Public Templates Videos root@kali:~# ls -la total 144 drwx------ 14 root root 4096 Sep 22 10:24 . drwxr-xr-x 19 root root 36864 Jul 27 15:41 .. -rw------- 1 root root 155 Sep 22 10:23 .bash_history -rw-r--r-- 1 root root 570 Jul 18 17:08 .bashrc drwx------ 6 root root 4096 Sep 22 11:21 .cache drwxr-xr-x 8 root root 4096 Sep 22 10:22 .config drwxr-xr-x 2 root root 4096 Sep 22 10:21 Desktop -rw-r--r-- 1 root root 55 Sep 22 10:21 .dmrc drwxr-xr-x 2 root root 4096 Sep 22 10:21 Documents drwxr-xr-x 2 root root 4096 Sep 22 10:21 Downloads -rw-r--r-- 1 root root 11656 Jul 27 13:22 .face lrwxrwxrwx 1 root root 11 Jul 27 13:22 .face.icon -> /root/.face drwx------ 3 root root 4096 Sep 22 10:24 .gnupg -rw------- 1 root root 306 Sep 22 10:24 .ICEauthority drwxr-xr-x 3 root root 4096 Sep 22 10:21 .local drwxr-xr-x 2 root root 4096 Sep 22 10:21 Music drwxr-xr-x 2 root root 4096 Sep 22 10:21 Pictures -rw-r--r-- 1 root root 148 Jul 18 17:08 .profile drwxr-xr-x 2 root root 4096 Sep 22 10:21 Public drwxr-xr-x 2 root root 4096 Sep 22 10:21 Templates drwxr-xr-x 2 root root 4096 Sep 22 10:21 Videos -rw------- 1 root root 98 Sep 22 10:24 .Xauthority -rw------- 1 root root 5961 Sep 22 10:24 .xsession-errors -rw------- 1 root root 6590 Sep 22 10:23 .xsession-errors.old root@kali:~#

Take note that filenames that start with a dot character before their names mean that they are hidden (e.g., .bash_history ). Also, at the far left before the permissions, the letter d means it's a directory and not a file. Finally, you can list another directory's contents differently than the current one by specifying the path of the destination folder:

$ls -la [destination directory path]

Permissions

For the permissions, the same principle applies to a file or a directory. To simplify it, the permissions are divided into three categories:

Read ( r ): 4

Write ( w ): 2

Execute ( x ): 1

The permissions template applies the following pattern:

[User:r/w/x] [group:r/w/x] [everyone:r/w/x]

Figure 1.6 Kali Linux – Files and Folders Commands

Let's look at a practical example. Lat's say you created a simple shell script that prints test (using the echo command) and that you wanted display its permissions (take note that this example uses the root user inside the terminal window):

root@kali:~# echo 'echo test'> test.sh root@kali:~# ls -la | grep 'test.sh' -rw-r--r-- 1 root root 10 Sep 22 11:25 test.sh root@kali:~#

From the previous output results, we can see the following:

For the root user, you can read and write because of rw at the beginning.

For the root group, they can only read this file.

For everyone else on the system, they can only read as well.

Let's say you want to execute this file, since you're the one who created it and you're the master root. Do you think you'll be able to do it (according to the previous permissions for the root user)?

root@kali:~# ./test.sh bash: ./test.sh: Permission denied

TIP

The dot in the previous example means the current directory.

Indeed, the root has no permission to execute