The command interpreter or shell is a program that allows users to interact with the system, processing the orders that are indicated. The commands that can be invoked from the shell can be classified as internal (actually correspond to commands interpreted by the shell itself) and external (correspond to executable files external to the shell). In addition to commands, the shells offers other elements to improve their functionality, such as variables, functions or control structures. The set of internal commands and available elements, as well as their syntax, will depend on the concrete shell used.
In addition to using the shell from the command line (based on the prompt as the indication of the shell to announce waiting for a command from the user), it can be used to interpret shell-scripts. A shell-script or “command script” is a text file that contains a set of commands and commands interpretable by the shell.
In the S.O.’s Unix, there are multiple shell implementations (in Windows, the equivalent would be the “command.com” or “cmd.exe” programs). Attending the shell from which they come and their syntactic similarity (including their internal commands), the Unix shells can be classified into two large families (there are some additional shell, residual use and within the shells of the same family there are also differences, but much of its syntax is common).
What’s a bash script? What they are and what they do?
Simple, a bash script, allows you to execute commands from a “file”. Why do we need to understand this? We need to understand that the “interpreter” is the shell. What do we mean when we say that the interpreter is the shell? Well, with a bash script, you can have unlimited functionality when it comes down to the Unix toolset, for example, if you are performing Python scripting, the whole idea of “modules” comes to mind, but, if we use bash scripting to create a script, it’s more convenient, because you won’t have to install dependencies, additional extensions or “modules”.
Is bash scripting better than Python scripting? Well, this point, depends on the background and perception of the programmer, but if you ask any system administrator, they will prefer bash scripting over Python, why?, because by comparing them, Python is less “reliable”
when it comes to “bashing”, on the other hand, in Unix, (remember, because the bash use the shell as an interpreter), the shell its build in on Unix, and will enable you to use the entire Unix toolset which means that you’ll be able to control sockets, just by typing each command on each line, this makes this process, very intuitive and easy to understand.
Running Bash scripts
Running a Bash script is fairly easy. Another term you may come across is “executing the script” (which means the same thing). Before we can execute a script it must have the execute permission set (for safety reasons this permission is generally not set by default). If you forget to grant this permission before running the script you’ll just get an error message telling you as such and no harm will be done.
Bash Scripting. Is the best… But, for what exactly?
Bash scripting allows system administrators to copy, update, and do backups of files, almost automatically. You can create bash scripts to do many tasks, that go from doing queries of data in an excel sheet file, up to compiling data, getting figures, and producing massive amounts of data. Of course, nothing is perfect, because when it comes to huge calculations that involve statistics and merging all the data types, it comes off short, Why? because the Shell is focused in running the system itself, but it is still useful for managing files, running scripts, programs, and especially, for automating tasks.
Lets create a simple bash script, as an example, and to understand the syntax and what we mean by interpreting a file.
You can do this using any Unix/Linux operating system, and the editor (shell) of your choosing. Lets create a bash script that will display the word HELLO
“echo” essentially is used to display the text “echoing” the tex back to you. This is basically a shell script. This is a command, that the shell will interpret when you press enter.
You can see it interprets and the shell “understand” what you are trying to do. We can complicate things a little bit, for example, by scripting, essentially allowing you to execute a lot of this commands from a file, using the shell, a thing that, sometimes, many people forget, and how powerful this possibility is.
As we know, you can create the script on any text editor of our choosing.
Remember that the file that we are going to create must be saved as a Shell extension (.sh) and we can locate it, on any place we want. Lets create a file called Simple.sh and save it in our Desktop.
Now the first thing we must do, is to declare what interpreter we are going to use in the file we just created.
This is called the “Shebang”, the reason it is called this? is because, this “#” is a “sharp” and this “!” is the bang, like the annotations you find in music sheets.
These characters #! are at the beginning of interpretable executable programs or scripts.
So, anything after the shebang line will essentially be used as the interpreter.
In this case, the bash is going to be used as the interpreter of the script that we are going to create. Remember you can use any interpreter after the shebang:
For example, to create a reverse scripting for reverse shells on a client or the Shell when you want to perform a privilege escalation:
The shell, remember, is different from the bash, given that the bash is considered a terminal instance, which will give you much more streamline experience when it comes down to using Unix/Linux operating systems, as for the shell, it is simply the interpreter of commands, and you know that this, won’t give you full access in terms of functionality.
We will use the bash.
In the following line we type the text we want to display between quotation marks, to make sure that everything in them, is printed out, but before we use our text editor to create the file Simple.sh, this can be visualized in the picture below:
Then we proceed to paste the following sentence into the new file
echo “Hello world! This is the first shell script”
We save the script, now, let’s execute it.
We open our terminal and go to the location of the script we just created
Lest make sure that we can execute the script giving to it “execute” permissions, using the chmod command:
/Desktop# chmod +x Simple.sh
Now to execute, we select the interpreter
Where ./ is “telling” the terminal that he must use the specified interpreter indicated after the “Shebang” of the script we want to run.
Now we run it like this:
Getting the following result:
Hello world! This is the first shell script
This is a very simple example to explain the syntax behind this procedure. What do we mean with this? that now we can understand how we can execute a script (series of commands and bashes) from a file (in this case “Simple.sh”), how when we build a script we “instruct” it to be used by an interpreter. To be able to know, by the Shebang present in a script, what is the interpreter you must use to run it (if the script you are about to use was not created by you), or if you are creating one, leave the “instructions” for another user that will use the bash, to run it using the interpreter present in the Shebang with this command (./) without reviewing it. You can also set permissions in the script to be used only by certain users with the chmod command.