Hacking_and_Penetration_Testing_with_Low_Power_Devices

Adding a graphical environment
57
board. Creating a variable to be used in the current shell is as simple as executing the
command variable¼value. Value can be any arbitrary string. A string that includes
whitespace can be enclosed in quotes. Single quotes tell the shell not to interpret
the string. Enclosing a value within double quotes will cause the shell to interpret wildcards
(such as *) and shell variables. In our case, we are running a set of commands and
assigning the result to a variable using the syntax variable¼$(command). This is
another neat trick you can use from within a Linux shell. For example, the command
cat $(ls *.txt) will type out the contents of all txt files within the current directory.
Three different commands are executed inside the parentheses in the second line
with the output of each command used as the input for the next. This process is
known as piping. Not surprisingly, the j or vertical pipe is used to join these commands
together. The cat /proc/cpuinfo command prints out the contents of the
cpuinfo pseudo file.
This information is then piped to the grep (GNU Regular Expression Parser) tool.
Grep allows you to search for patterns. The special character ^anchors the search
expression to the start of a line ($ is used at the end to anchor an expression to
the end of a line). The command grep “^Hardware” prints out only lines that begin
with “Hardware.”
This line that identifies our board is then piped to our last command awk '{print
$4}'. Notice the use of single parentheses. This is done to prevent the $4 and curly
brackets from being interpreted by the shell. Awk is a pattern scanning and processing
language that was developed in the late 1970s. It is still widely used today, often
in combination with the stream editor sed. Awk commands are enclosed within curly
brackets. Our awk command simply prints the fourth word (set of characters separated
by whitespace) from our line. The net of all this is that the board variable has
been set appropriately in order to load the appropriate packages and create configuration
files later in the script.
The third and fourth lines are simple and straightforward. The command sudo
apt-get update updates the local directory of available packages. The command
is prefixed with sudo because it requires root (administrative) privileges. After
you run this command from a terminal, a number of messages starting with hit
(checking a repository), get (actually download a list), and ign (ignore a repository
previously updated) will be displayed. A shell prompt will be displayed when the
command finishes. All installed packages are upgraded to the latest version by
the sudo apt-get -y upgrade on the fourth line. The -y flag automatically answers
yes to any prompts. Running this command from a terminal will cause a summary of
what is to be updated and what will be held back to be displayed, then the packages to
be updated will be fetched (the status message will start with get, followed by a number
corresponding to the nth package to be updated during this operation), and finally
the packages are reinstalled.
The next few lines define a simple function. The syntax for creating functions is
straightforward. Simply list a function name, followed by parentheses and then
enclose the commands that make up the function in curly brackets. You can create