Med Java

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Useful commands - linux / ubuntu ======

===== [file] Show file type =====
<code>
file file.txt
</code>

===== [cat] Add line numbers to a file =====
<code>
cat -n file.txt
nl file.txt
</code>

===== [tree] Show tree of files =====
<code>
tree -F -L 1 /
</code>
-F - show file type \\
-L - level (how nested should be), 1 - show only files under first directory level.

===== [ln] Symbolic link =====
<code>
ln -s lab02/.Hulk hulk
</code>
This will create file hulk as a shortcut for the (original) file lab02/.Hulk

===== [tar] Create a tar archive =====
<code>
tar -cvf archive.tar decrypted_file.txt encrypted_file.enc dir2
</code>
c - create \\ 
v - verbose\\ 
f - file name of the archive

===== [tar] Add a new file to the tar archive =====
<code>
tar -uf documente.tar raport_nou.txt
tar -rf documente.tar raport_nou.txt
</code>
-u - update \\ 
-r - add (does not check if the file is newer)

===== [tar] View tar archive content =====
<code>
tar -tf archive.tar
</code>
t - table (view archive content as a 'table') \\ 
f - file name (archive name) \\ 

===== [tar] Extract tar content =====
<code>
tar -xvf archive.tar
</code>
x - extract \\ 
v - verbose \\ 
f - file

===== [tar] Create a tar.gz archive =====
<code>
tar -czvf archive.tar.gz decrypted_file.txt encrypted_file.enc dir2
</code>
z - compressed gzip \\ 
c - create \\ 
v - verbose \\ 
f - file name of the archive

===== [gunzip] Add a file to existing tar.gz archive =====
This cannot be done directly using tar tool, but we will use gunzip to extract the tar archive, add a new file to it and then gzip it again.

<code>
gunzip archive.tar.gz && tar -rf archive.tar newfile.txt && gzip archive.tar
</code>

===== [tar] View tar.gz archive content =====
<code>
tar -tzf archive.tar.gz
</code>
t - table (view archive content as a 'table') \\ 
z - compressed gzip \\ 
f - file name (archive name)

===== [tar] Extract tar.gz content =====
<code>
tar -xzvf archive.tar.gz
</code>
x - extract \\ 
v - verbose \\ 
f - file

===== [zip] Create a zip archive =====
<code>
zip archive.zip file1.txt file2.txt
</code>

===== [zip] Add a new file to the zip archive =====
<code>
zip -u archive.zip new_file
</code>
-u - update (or add if not already in the archive)

===== [zip] View zip archive contents =====
<code>
zip -sf archive.zip
zip --show-files archive.zip
</code>

===== [zip] Extract a zip archive =====
<code>
unzip archive.zip -d dir
</code>
-d - optional destination directory, if missing the current directory will be used.

===== Find a file / directory =====

==== [find] Find all txt files in the users home directory ====
<code>
find ~ -name "*.txt"
</code>

==== [find] Find insensitive ====
<code>
sudo find / -iname "*ssh*conf"
</code>

==== [find] Find all files > 100 MB ====
<code>
find ~ -type f -size +100M
</code>

==== [find] Find and remove all files in /tmp directory ====
<code>
find /tmp -type f -name "*.tmp" -exec rm {} \;
</code>
{} - placeholder for each file, it will contain the full path name \\ 
\; - marks the end of the command

==== [find] Find executable files ====
<code>
find . -type f -executable
</code>

==== [find] Find all empty directories (and subdirectories) ====
<code>
find . -type d -empty
</code>

==== [find] Find all files that contain at least one digit (number) from a directory ====

<code>
find /usr/include -name '*[0-9]*'
</code>
{{:linux:ubuntu:pasted:20240207-200334.png}}

===== Locate a file (searching in database instead of actual files on disk) =====

==== [locate] Installing the locate tool ====
<code>
sudo apt install mlocate
sudo updatedb
</code>

==== [locate] Locate a file ====
<code>
locate "*ssh*conf"
</code>

==== [locate] Locate a file insensitive ====
<code>
locate -i "Example.txt"
</code>

==== [locate] Locate only the first 10 results ====
<code>
locate example.txt | head -10
</code>

===== [ps] List all active processes =====
<code>
ps -ef
</code>
e - 'every' - we want to see every process \\ 
f - 'full' - get full details

<code>
ps aux
</code>
a - all users \\
u - user oriented format output (display user who owns the process, CPU, memory, etc.) \\
x - also includes the processes that are not attached to a terminal.

{{:linux:ubuntu:pasted:20240206-172056.png?0x300}}

===== [ps] List all processes of a certain user =====
<code>
ps -u username
</code>

===== [ps] List details of a specific process =====
Change 2638 with the actual process pid.
<code>
ps -p 2638
</code>

===== [ps] List processes based on cpu usage =====
<code>
ps -aux --sort=-%cpu
</code>

===== [ps] List processes based on memory usage =====
<code>
ps -aux --sort=-%mem
</code>

===== [ps] List processes with custom columns =====
<code>
ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=%mem
</code>

===== [ps] List processes - descending sorting =====
Just add a - in the --sort.
<code>
ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | less
</code>

===== [ps] Search for a specific process =====
Replace gnome with your keyword.
<code>
ps -ef | grep gnome
</code>

===== [pstree] List the process tree =====
<code>
pstree
pstree -u
pstree -p
</code>
u - show users
p - show pid

===== Get the pid of a process =====
Multiple methods:

<code>
pgrep nginx
</code>

<code>
ps aux | grep nginx | grep -v grep
</code>

<code>
pidof nginx
</code>

===== [apt] APT commands =====
<code>
sudo apt install nginx
sudo apt search nginx
sudo apt remove nginx
sudo apt purge nginx
sudo apt update
sudo apt upgrade
</code>

===== [ip] Check if a network card is active =====
<code>
sudo ip link show
</code>

===== [ip] UP / DOWN states of network interfaces =====

Display only the names and states (UP / DOWN) of the network interfaces on the system, using the format interface_name:state.

<code>
ip link show | awk '/^[0-9]+:/ {print $2 " " $9}' | sed 's/://g' | awk '{print $1 ":" ($2=="UP"?"UP":"DOWN")}'
</code>
Output:
<code>
lo:DOWN
ens33:UP
ens34:UP
docker0:DOWN
br1:DOWN
br2:DOWN
</code>

===== [ip] Start a network interface =====

<code>
ip link set dev eth1 up
</code>

===== [ip] View IPs on all network interfaces =====

<code>
sudo ip address show
</code>

===== [ip] Remove a network configuration from an interface =====

<code>
sudo ip address flush eth1
</code>

===== [ping] Check if a station is alive =====

<code>
ping -c 4 10.125.50.50
</code>
c - number of packets to send (by default is infinite)

===== [ip] Show routing table / find default gateway =====

<code>
ip route show
</code>

Default gateway (192.168.112.2) is listed under the 'default via' section:

{{:linux:ubuntu:pasted:20240206-175930.png}}

To extract just the default gateway ip:
<code>
ip route show | awk 'NR==1 {print $3}'
</code>
{{:linux:ubuntu:pasted:20240208-024419.png}}
===== [ip] [nmcli] Find DNS Servers =====
<code>
nmcli dev show | grep DNS
</code>

{{:linux:ubuntu:pasted:20240206-180303.png}}

<code>
resolvectl status | grep 'Current DNS'
</code>

{{:linux:ubuntu:pasted:20240206-180425.png}}

To print only IPs:
<code>
nmcli dev show | grep DNS | cut -d ':' -f2 | tr -d ' '
</code>
===== [ip] [host] Get the IP address of a host / Check if DNS service is working =====

<code>
host elf.cs.pub.ro
</code>

{{:linux:ubuntu:pasted:20240206-180627.png}}

===== Update DNS Servers =====

Change the /etc/resolv.conf:
nameserver 8.8.8.8
nameserver 8.8.4.4

===== [netstat] Display open UDP ports =====

<code>
sudo netstat -ulpn
</code>
u - udp ports only \\ 
l - listening state ports only \\ 
p - program name / PID that has opened the port \\ 
n - shows the actual IP address on which the system is listening for connections, instead of resolving the host name.

<code>
sudo ss -ulpn
</code>

===== [netstat] Display open TCP ports =====
<code>
sudo netstat -tlpn
</code>
t - TCP

<code>
sudo ss -tlpn
</code>

===== [netstat] Display both TCP and UPD ports =====
<code>
sudo netstat -tulpn
</code>
t - TCP \\ 
u - UDP
<code>
sudo ss -tulpn
</code>

===== [nc] Establish a TCP communication with an application - Netcat =====

<code>
nc google.com 80
</code>

{{:linux:ubuntu:pasted:20240206-182806.png}}

===== [wget] Download a single file from a HTTP(s) / FTP server =====
<code>
wget elf.cs.pub.ro
</code>

Download in background with a custom file name:
<code>
wget -b -O google.html http://google.com
</code>
b - run in background \\ 
O - output file name.

===== [curl] Show only HTTP Header of a site =====

<code>
curl -I -L http://ocw.cs.pub.ro
</code>
I (or --head) - send only HTTP HEAD request instead of HTTP GET \\ 
L - follow any redirectrion.

===== [ssh] Connect to a SSH server =====
<code>
ssh user@192.168.1.8
</code>

===== [ssh] Connect to a SSH server and run a command =====
<code>
ssh root@10.10.10.3 ip address show
</code>

===== [scp] Send / copy a file to a remote machine =====
<code>
scp /home/file.txt student@10.10.10.3:~/
</code>

===== [scp] Receive / download a file from a remote machine =====
<code>
scp student@10.10.10.3:/home/file.txt ~/
</code>

===== [scp] Send / copy a directory to a remote machine =====
<code>
scp -r /home/dir student@10.10.10.3:~/
</code>

===== [scp] Receive / download a file from a remote machine =====
<code>
scp -r student@10.10.10.3:/home/dir ~/
</code>

===== [ssh][public key] SSH Public Key authentication =====
<code>
ssh-keygen -t rsa -b 4096
ssh-copy-id root@10.10.10.3
</code>

What was generated:
  * ~/.ssh/id_rsa --> private key
  * ~/.ssh/id_rsa.pub --> public key
===== [ls] Escaping globbing patterns / special characters =====
Just enclose the string in ""
<code>
ls support-globbing/"[HOME]"*
</code>
<code>
find . -name "*search*"
</code>

===== Get memory information =====
<code>
cat /proc/meminfo | grep "Mem"
</code>

{{:linux:ubuntu:pasted:20240206-190522.png}}

===== Get CPU information =====
<code>
cat /proc/cpuinfo
</code>

===== [grep] Search for a string in a file =====
<code>
cat workspace/C/searching/binary_search.c | grep search
</code>

<code>
grep search workspace/C/searching/binary_search.c
</code>

<code>
grep 'error' log.txt
</code>

===== [grep] Case insensitive search for a string in a file =====
<code>
grep -i 'string_to_search' file.txt
</code>

===== [grep] Count number of lines of searched string in file  =====
<code>
grep -c 'cache' /proc/cpuinfo
</code>

===== [grep] Count number of occurrences (not just lines) of searched string in file  =====
<code>
grep -o 'searched_string' file.txt | wc -l
</code>
o - print each occurrence on a separate line \\ 
l (from wc) - count lines

===== [grep] Recursive search for a string in a directory =====
<code>
grep -r 'cache' /proc 2>/dev/null
</code>
2>/dev/null - don't show errors

===== [grep] Recursive (and insensitive with line number displayed) search for a string in a directory =====
<code>
grep -nri search workspace/C/ | less
</code>
n - show line number \\ 
r - recursive \\ 
i - case insensitive

===== [grep] Recursive search for a word in a directory =====
<code>
grep -nri -w "search" workspace/C/ | less
</code>

===== [grep] Display lines that does NOT contain the searched string =====
Show all lines that does not contain error string:
<code>
grep -v 'error' log.txt
</code>

===== [grep] Display lines that starts with a certain string =====
Search for lines that starts with error string:
<code>
grep '^error' log.txt
</code>

===== [grep] Display a certain number of lines AFTER matching a string in a file =====
Displays each line that contains error, followed by 3 lines:
<code>
grep -A 3 'error' log.txt
</code>

===== [grep] Display a certain number of lines BEFORE matching a string in a file =====
Displays two lines before each line that contains error:
<code>
grep -B 2 'error' log.txt
</code>

===== [grep] Display a certain number of lines BEFORE and AFTER matching a string in a file =====
Displays two lines before and after each line that contains error:
<code>
grep -C 2 'error' log.txt
</code>

===== [grep] Search in a file for one string OR another using ERE (Extended Regular Expressions) =====
<code>
grep -E -i "error(s)?|warning(s)?" example.txt
</code>

<code>
E - extended regular expression
i - case insensitive
error(s) - search for strings that contains error or errors
| - or
warning(s) - search for string that contains warning or warnings
? - makes that previous element (s) to be optional.
</code>

{{:linux:ubuntu:pasted:20240206-203038.png}}

===== [grep] Search in a file for an exact match of string OR another using ERE (Extended Regular Expressions) =====
<code>
grep -E -i "\berror(s)?|warning(s)?\b" example.txt
</code>
\b - the match will be made at the start and at the end of a word.

{{:linux:ubuntu:pasted:20240206-203834.png}}

===== [grep] Add an alias - go for xdg-open =====
Instead of running xdg-open https://google.com, we want to use go https://google.com. \\ 
For this we need to define an alias in **~/.bash_aliases** (this is read from **~/.bashrc**). \\ 
So we need to append line: alias go='xdg-open'

<code>
grep -qxF 'alias go='\''xdg-open'\''' ~/.bash_aliases || echo 'alias go='\''xdg-open'\''' >> ~/.bash_aliases
</code>

<code>
|| - the command after this OR operator will be executed if the command before it fails.
q - run in silent mode, without printing anything
x - search on the ENTIRE line
F - disable regular expression, the string is a simple text.
>> - append to the end.
</code>

Next, reload the ~/.bashrc file:
<code>
source ~/.bashrc
</code>

===== [;] Execute multiple commands in the same line, one by one =====
<code>
mkdir demo; cd demo; touch Hello; ls
</code>

===== [&&] Execute a command on the same line if the PREVIOUS one SUCCEEDED =====
<code>
mkdir operators/demo && cd operators/demo
</code>

===== [||] Execute a command on the same line if the PREVIOUS one FAILED =====
<code>
ls -d operators || mkdir operators
</code>

===== [find] Print info about files in the current directory using FIND with -exec =====
<code>
find . -maxdepth 1 -type f -exec ls -l {} \;
</code>

===== [find] Print info about files in the current directory using FIND and PIPE =====
<code>
find . -maxdepth 1 -type f -print0 | xargs -0 ls -l
</code>
-print0 - finish each string found with a null character instead of newline. This helps in manipulating files that contains spaces or newlines. \\ 
0 - treat received input as a list of args separated by the null character - used to correctly processed the output of print0.

===== [find] Find all files from /lib that does not start with the lib prefix =====

<code>
find -L /lib -type f -not -name 'lib*.*'
</code>
L - follow symlinks (this is necessary because lib is a symlink for usr/lib) \\ 
not - negate the name

===== [xargs] Move all files (requiring confirmation) with a certain extension from the current folder to parent =====
<code>
ls *.c | xargs -I {} -p mv {} ..
</code>
I {} - placeholder / replacer for each character \\ 
p - requires user confirmation

Safer version (handles better the files with spaces):
<code>
find . -maxdepth 1 -type f -name "*.c" -exec mv {} .. \;
</code>

===== [1> 2>] Redirect STDOUT and STDERR =====
Redirect both in firefox-ignore file.
<code>
firefox &> firefox-ignore
</code>
Another way:
<code>
firefox > firefox-ignore 2>&1
</code>
To redirect input in a file and output to another file:
<code>
firefox > firefox-output.txt 2> firefox-error.txt
</code>
OR
<code>
firefox 1> firefox-output.txt 2> firefox-error.txt
</code>
<code>
> is equivalent to 1>
</code>

===== [dd] Generate 100 MB file with null values =====
<code>
dd if=/dev/zero of=null-100mb count=100 bs=1M
</code>
if=/dev/zero - input file will get data from /dev/zero \\ 
of=null-100mb - name of the output file \\ 
count=100 - number of blocks that will be copied \\ 
bs=1M - size of each block

===== [dd] Generate 100 MB file with random values =====
<code>
dd if=/dev/urandom of=rand-100mb count=100 bs=1M
</code>

===== [grep] Simple Regular Expressions Examples =====

Search for lines that starts with Hello:
<code>
grep '^Hello' message.txt
</code>

Search for lines that ends with ending:
<code>
grep 'ending$' message.txt
</code>

Search any lines that contains e followed by any character and then r:
<code>
grep 'e.r' message.txt
</code>

Search lines that contains sc followed by h or y and the o:
<code>
grep 'sc[hy]o' wordlist.txt
</code>

Search lines that contains sc followed any character except h or y and the o:
<code>
grep 'sc[^hy]o' wordlist.txt
</code>

Lines with the character o at least once:
<code>
grep -E 'o+' wordlist.txt
</code>

This means o with zero or more apparitions. So it will match everything:
<code>
grep -E 'o*' wordlist.txt
</code>

Search for one or another
<code>
grep 'succes|error' mesaje.txt
</code>

===== [grep] List lines that starts with a certain letter =====
Students whose name starts with G:
<code>
grep '^G' students.txt
</code>
{{:linux:ubuntu:pasted:20240206-223122.png}}

===== [grep] List students with any secondary name that starts with F =====

<code>
grep '[ -]F[a-z]\+[^\.]' students.txt
</code>
[ -]F - space or - followed by F \\
[a-z]\+ - any a-z characters at least once. In standard grep (not extended) + should be prefixed with \ \\ 
[^\.] - following character is not . \\ 

{{:linux:ubuntu:pasted:20240206-224337.png}}

===== [ls] List files with .txt extension and a single character before extension =====

<code>
ls ?.txt
</code>
? - any unique character

{{:linux:ubuntu:pasted:20240206-225028.png}}

===== [ls] List all files that starts with a, b or c and have the .txt extension =====

<code>
ls [abc]*.txt
</code>
[abc] - characters a, b or c \\ 
* - any number of characters (including 0) \\ 
.txt - ends with txt

===== [grep] List students with their father initial followed optionally by . in their name =====

<code>
grep -E ' [A-Z]\.? ' students.txt
</code>
\.? - optional dot

===== [tr] Convert spaces and tabs to comma =====

<note>
tr is used for translating or deleting characters.
</note>

<code>
cat students.txt | tr " " "," | tr "\t" ","
</code>

OR

<code>
cat students.txt | tr " \t" ","
</code>

OR (much more cleaner)

<code>
tr " \t" "," < students.txt
</code>

{{:linux:ubuntu:pasted:20240206-232944.png}}

===== [tr] Convert lowercase string to uppercase =====
<code>
echo "hello world" | tr 'a-z' 'A-Z'
</code>
{{:linux:ubuntu:pasted:20240206-231910.png}}

===== [tr] Delete characters from a to e =====

<code>
echo "hello world" | tr -d 'a-e'
</code>
{{:linux:ubuntu:pasted:20240206-232023.png}}

===== [tr] Squeeze repetition of characters =====

<code>
echo "helloooo world" | tr -s 'o'
</code>
{{:linux:ubuntu:pasted:20240206-232241.png}}

===== [sed] Replace entire text =====

<note>
sed (Stream Editor) is used for filtering and transforming text (not just characters like tr)
</note>

<code>
echo "hello world" | sed 's/world/universe/'
</code>
{{:linux:ubuntu:pasted:20240206-233424.png}}

===== [sed] Replace first occurrence =====

<code>
echo "apa de apa" | sed 's/apa/apa minerala/'
</code>
s - init substitution command

{{:linux:ubuntu:pasted:20240206-234812.png}}

===== [sed] Replace all occurrences =====

<code>
echo "apa de apa" | sed 's/apa/apa minerala/g'
</code>
g - substitution will be applied globally (for all occurrences on that line)

{{:linux:ubuntu:pasted:20240206-234958.png}}

===== [sed] Delete lines =====

<code>
echo -e "hello\nworld" | sed '/world/d'
</code>
{{:linux:ubuntu:pasted:20240206-233713.png}}

===== [sed] Insert text after a match =====

If line1 is found, it will insert line1.5 after it.
<code>
echo -e "line1\nline2" | sed '/line1/a\line1.5'
</code>
{{:linux:ubuntu:pasted:20240206-234037.png}}

===== [sed] Edit the file in place =====

Replaces all occurrences of "old" with "new" in file.txt directly, modifying the file in place. \\ Use with caution and ideally with a backup.
<code>
sed -i 's/old/new/g' file.txt
</code>
i - in place

===== [cut] Print the first two columns (separated by space) from a file =====
<note>
cut is used to extract columns from a file delimited with a specific character.
Default separator is tab (\t).
</note>

<code>
cut -d ' ' -f1,2 students.txt
</code>
-d ' ' - delimiter is space \\ 
-f1,2 - column numbers to extract (starts with index 1)

{{:linux:ubuntu:pasted:20240207-000923.png}}

===== [cut] List only the first bytes from each line =====

<code>
cut -b 1,2,3 students.txt
</code>
{{:linux:ubuntu:pasted:20240207-001501.png}}

<code>
cut -b 1-5 students.txt
</code>
{{:linux:ubuntu:pasted:20240207-001534.png}}

===== [cut] List only specific characters from each line =====

<code>
cut -c 2,5,7 state.txt
</code>
{{:linux:ubuntu:pasted:20240207-001816.png}}

<code>
cut -c 1-7 students.txt
</code>
{{:linux:ubuntu:pasted:20240207-001905.png}}

===== [awk] Extract column using a custom separator =====

<code>
awk -F: '{print $1}' /etc/passwd
</code>
F - field separator

===== [awk] Use multiple delimiters to extract columns from a file =====

Another way to set delimiter is in the BEGIN block.
<code>
awk 'BEGIN{FS="[ \t]+"} {print $1}' students.txt
</code>
BEGIN - special block used to adjust the initial settings before executing awk. \\  
FS - field separator. \\ 
[ \t]+ - one or more spaces or tabs. \\ 
$1 - first column

{{:linux:ubuntu:pasted:20240207-004733.png}}

===== [awk] Skip first two lines =====

<code>
w | awk 'FNR>2 {print $1}'
</code>
FNR - file number record (internal awk variable holding current line number).

===== [awk] Skip first column - print just other columns not the first one =====

<code>
history | awk '{$1=""; print $0}'
</code>

<code>
{$1=""} - sets the first column (represented by $1) to an empty string, effectively removing it from the output. \\ 
print $0 - prints the entire line to the output.
</code>

===== [awk] Skip first two columns =====

<code>
history | awk '{$1=""; $2=""; print $0}'
</code>

===== [awk] Add a header to the output and display the entire file content =====

<code>
awk 'BEGIN {print "The File Contents:"} {print $0}' students.txt
</code>
{{:linux:ubuntu:pasted:20240207-005907.png}}

===== [awk] Add a header and a footer to the output and display the entire file content =====

<code>
awk 'BEGIN {print "The File Contents:"} {print $0} END {print "This is the end my friends."}' students.txt
</code>
{{:linux:ubuntu:pasted:20240207-010258.png}}

===== [awk] Display first word (string followed by a space) from each line of a file =====
<note>
awk is similar with cut but much more advanced. \\ 
Default column separator is any whitespace (space, tab) and newline.
</note>

<code>
awk '{print $1}' students.txt
</code>
$1 - first column

{{:linux:ubuntu:pasted:20240207-002957.png}}

===== [awk] Display last word (string followed by a space) from each line of a file =====

<code>
awk '{print $NF}' students.txt
</code>
NF - number of fields (last column number)

{{:linux:ubuntu:pasted:20240207-003342.png}}

===== [awk] Display entire line and change some column values =====

<code>
echo "Hello Tom" | awk '{$2="Adam"; print $0}'
</code>
$0 - entire line

{{:linux:ubuntu:pasted:20240207-005442.png}}

===== [awk] List students with notes greater than 5 =====

<code>
awk '$5 > 5 {print $1, $2, $5}' students.txt
</code>
{{:linux:ubuntu:pasted:20240207-003553.png}}

===== [awk] Compute the average of final grades =====

<code>
awk '{sum += $5} END {print "Average of final grades:", sum/NR}' students.txt
</code>
sum - custom variable to count the sum (it is not predefined). \\ 
$5 - fifth column. \\
END - block which will be executed after all lines from the file were processed. \\
NR - internal awk variable which stores the total number of lines.

{{:linux:ubuntu:pasted:20240207-003913.png}}

===== [awk] Customize the columns output =====

Print - between the first and second column:
<code>
awk '{print $1, "-", $2}' students.txt
</code>

===== [awk] Multiply column value based on a condition =====

<code>
awk '{ if ($5>=5) { nr=$5*10} else { nr=$5 } print nr}' students.txt
</code>
{{:linux:ubuntu:pasted:20240207-010904.png}}

===== [awk] Print only lines 5 and 7 from /etc/passwd =====

<code>
cat /etc/passwd | awk 'NR==5 || NR == 7 {print $0}'
</code>
{{:linux:ubuntu:pasted:20240207-205849.png}}

===== [seq] Generate a sequence of numbers from 1 to 5 =====
<code>
seq 1 5
</code>
{{:linux:ubuntu:pasted:20240207-101045.png}}

===== [seq] Generate a sequence of numbers from 1 to 10, with an increment of 2 =====

<code>
seq 1 2 10
</code>
{{:linux:ubuntu:pasted:20240207-101200.png}}

===== [seq] Generate a sequence of numbers from 0.5 to 2.5, with an increment of 0.5 =====

<code>
seq 0.5 0.5 2.5
</code>
{{:linux:ubuntu:pasted:20240207-101317.png}}

===== [seq] Generates numbers with two decimal places =====

<code>
seq -f "%.2f" 1 3
</code>
f - format

{{:linux:ubuntu:pasted:20240207-101459.png}}

===== [seq] Generate numbers with equal width (added 0 in front) =====

<code>
seq -w 1 10
</code>
w - equal width for all generated numbers

{{:linux:ubuntu:pasted:20240207-101808.png}}

===== [sort] Sort numbers ascending order =====
<note>
sorts the text lines.
By default it will sort as characters.
</note>

<code>
echo -e "5\n3\n8\n1" | sort -n
</code>
e - interpret escape sequences \\ 
n - numbers (sort as numbers)

{{:linux:ubuntu:pasted:20240207-103102.png}}

===== [sort] Sort numbers descending order =====

<code>
echo -e "5\n3\n8\n1" | sort -nr
</code>
r - reverse (descending) order

{{:linux:ubuntu:pasted:20240207-103128.png}}

===== [sort] Sort by a certain column  =====

Sort numerically by second column.
<code>
echo -e "a 2\nc 1\nb 3" | sort -n -k2
</code>
k2 - sort by second column

{{:linux:ubuntu:pasted:20240207-103529.png}}

Sort lexicographically by first column. \\ 
(k1 can be omitted here, sort will automatically sort lexicographically by the first column.)
<code>
echo -e "a 2\nc 1\nb 3" | sort -k1
</code>

{{:linux:ubuntu:pasted:20240207-112253.png}}
===== [sort] Sort by multiple columns =====

<code>
cat multiple.txt | sort -k1,1 -k2,2gr
</code>
k1,1 - sort entire first column \\ 
k2,2 - sort entire second column \\ 
g - general numeric sort (sort better different kind of numbers for ex 2, 2.5, 3.55) \\ 
r - reverse

{{:linux:ubuntu:pasted:20240207-111158.png}}

===== [sort] Unique sort - sort and remove duplicates =====

<code>
cat multiple.txt | sort -k1,1 -u
</code>
u - unique

{{:linux:ubuntu:pasted:20240207-111939.png}}

===== [sort] Sorting with a specific separator =====

Default separator is tab (\t). We want to change it to :.

<code>
echo -e "a:2\nb:1\nc:3" | sort -t: -k2
</code>
t - change separator

{{:linux:ubuntu:pasted:20240207-112133.png}}

===== [sort] Check if the column is sorted (without sorting it, just check) =====

<code>
echo -e "a 2\nc 1\nb 3" | sort -c
</code>
c - check

{{:linux:ubuntu:pasted:20240207-104223.png}}

===== [uniq] Remove duplicated lines =====

<code>
sort file.txt | uniq
</code>
{{:linux:ubuntu:pasted:20240207-183016.png}}

To match the lines case insensitive:
<code>
sort file.txt | uniq -i
</code>

===== [uniq] Remove duplicated lines and count occurences =====

<code>
sort file.txt | uniq -c
</code>
c - count

{{:linux:ubuntu:pasted:20240207-183042.png}}

===== [uniq] Show only lines that appear multiple times =====

<code>
sort file.txt | uniq -d
</code>
d - duplicated

{{:linux:ubuntu:pasted:20240207-183234.png}}

===== [uniq] Show only not duplicated lines =====

<code>
sort file.txt | uniq -u
</code>
u - unique

{{:linux:ubuntu:pasted:20240207-183351.png}}

===== [sort] [uniq] [awk] Most used 10 history commands =====

<code>
history | awk '{$1=""; print $0}' | sort | uniq -c | sort -nr -k1 | head -10 | awk '{$1=""; print $0}'
</code>

===== [for] Start 10 processes in background then kill them =====

<code>
for i in {1..10}; do sleep 3000 & done; pkill sleep
</code>

===== [for] Create 15 files - their names contains numbers =====

Using a one-liner, create 15 files with names ranging from final-exam-00.txt to final-exam-15.txt.

<code>
for i in {0..15}; do touch final-exam-$(printf "%02d" $i).txt; done
</code>

===== [bash] All types of arguments in a bash script =====

<code bash arg.sh>
#!/bin/bash
 
echo "All args"
 
echo "Using \$*:"
for arg in "$*"; do
    echo "$arg"
done
 
echo "Using \$@:"
for arg in "$@"; do
    echo "$arg"
done
 
echo "Using \$1, \$2, ..."
echo "Arg 1: $1", "Arg 2: $2"
 
echo "Script name is $0"
 
echo "Number of args received is $#"
 
echo "Printing all args using \$# and a for loop"
 
nr_args=$#
 
for (( i=1; i<=$nr_args; i++ ))
do
	eval arg=\${$i}
	echo "Arg $i is: $arg"
done
</code>
{{:linux:ubuntu:pasted:20240207-012912.png}}

===== [bash] $var vs ${var} =====

{{:linux:ubuntu:pasted:20240207-112745.png}}

===== [bash] Get the length (number of characters) of a variable =====

{{:linux:ubuntu:pasted:20240207-112900.png}}

===== [bash] Extract a substring from a variable =====

Extract from position 7 with a length of 5 characters:

{{:linux:ubuntu:pasted:20240207-113033.png}}

===== [bash] Command substitution - $() structure =====
<note>
The $(...) syntax in Bash is used for command substitution. It allows the output of a command to replace the command itself in a line of script or command input. This is particularly useful when you need to use the output of one command as an argument for another command, or when assigning the output of a command to a variable.
</note>

{{:linux:ubuntu:pasted:20240207-114022.png}}

Execute a command based on the condition of another command:
<code>
if [[ $(grep -c "searched_word" fisier.txt) -gt 0 ]]; then
    echo "Word was found in the file."
else
    echo "Word was not found, sorry."
fi
</code>

Iterate through files:
<code>
for file in $(ls *.txt); do
    echo "Processing txt file: $file"
done
</code>

Nesting commands (find kernel version):
{{:linux:ubuntu:pasted:20240207-114534.png}}

===== [bash] [while-read] Read a file and assign a variable for each column =====

<code bash while-read.sh>
#!/bin/bash
 
IFS=$'\t'
while read name group final_grade test_grade practical_grade; do
    echo "$name --> $group --> $final_grade --> $test_grade --> $practical_grade"
done < students.txt
</code>
IFS - defines the separator, here tab (\t).

{{:linux:ubuntu:pasted:20240207-014050.png}}

===== [bash] [while-read] Read a file and adjust values based on a condition =====

<code bash while-read-cond.sh>
#!/bin/bash
 
IFS=$'\t'
while read name group final_grade test_grade practical_grade; do
	if test "$final_grade" -gt 5; then
        	echo "$name --> $group --> Good job, final grade is $final_grade --> $test_grade --> $practical_grade"
    	fi
	echo "$name --> $group --> $final_grade --> $test_grade --> $practical_grade"
done < students.txt
</code>
{{:linux:ubuntu:pasted:20240207-014529.png}}

===== [bash] [for] Script for manipulating all files from a folder (print information about them, make backups) =====

<code bash manip.sh>
#!/bin/bash

for file in "$1"/*
do
    if test -f "$file"; then
        stat -c "%a %F %n" "$file"
        cp "$file" "$file.bkp"
    fi
done
</code>
%a - file permission in numeric form. \\
%F - file type. \\ 
%n - complete file name.

===== [bash] [rm] Script that removes itself =====

<code bash nothing.sh>
#!/bin/bash

rm -- "$0"
</code>
-- - end of command line options. \\ 
"$0" - the name of the script.

===== [bash] [for] Script to print the sum of the received arguments, error if no argument =====

<code bash dumb-sum.sh>
#!/bin/bash

nr_args=$#

if [ "$nr_args" -eq 0 ]; then
    echo "Error: No arguments provided. Usage: $0 <arg1> <arg2> ..."
    exit 1
fi

sum=0

for (( i=1; i<=$nr_args; i++ ))
do
	eval arg=\${$i}
	 sum=$((sum + arg))
done

echo "Sum is: $sum"
</code>

<note important>
<code>
$((sum + arg)) is to evaluate arithmetic expression.
</code>
</note>

===== [bash] Advanced dictionary lookup script =====

Script to download the wbritish package (contains dictionaries) and which should validate the words from in.txt file located at [[http://elf.cs.pub.ro/uso/res/final/146/in.txt|in.txt]] with the words from the dictionary. \\ 
Example:
<code>
./lookup.sh in.txt
apple in dictionary
noapple not in dictionary
</code>

Lookup script with the in.txt file downloaded locally (using wget http://elf.cs.pub.ro/uso/res/final/146/in.txt)
<code bash lookup.sh>
#!/bin/bash

if [ "$#" -ne 1 ]; then
    echo "Usage: $0 <input_file>"
    exit 1
fi

input_file=$1

if ! dpkg -l | grep -qw wbritish; then
    echo "Installing wbritish package."
    sudo apt-get update && sudo apt-get install -y wbritish
fi

if [ ! -f "$input_file" ]; then
    echo "File does not exist: $input_file"
    exit 2
fi

while IFS= read -r word; do
    if look "$word" /usr/share/dict/british-english > /dev/null; then
        echo "$word in dictionary"
    else
        echo "$word not in dictionary"
    fi
done < "$input_file"
</code>
Output:
<code>
./lookup.sh in.txt
mine in dictionary
yours not in dictionary
apples in dictionary
notSoApples not in dictionary
</code>

Lookup script that will download the in.txt file from the remote location:
<code bash lookup.sh>
#!/bin/bash

if [ "$#" -ne 1 ]; then
    echo "usage: $0 <input_file>"
    exit 1
fi

input_file_url=$1
input_file="in.txt"

wget -O "$input_file" "$input_file_url" || { echo "Eroare downloading input file."; exit 2; }

if ! dpkg -l | grep -qw wbritish; then
    echo "wbritissh not installed, installing"
    sudo apt-get update && sudo apt-get install -y wbritish
fi

if [ ! -f "$input_file" ]; then
    echo "input file does not exist: $input_file"
    exit 2
fi

#read each word from input file and check if it is present in dictionary

while IFS= read -r word; do
    if look "$word" /usr/share/dict/british-english > /dev/null; then
        echo "$word in dictionary"
    else
        echo "$word not in dictionary"
    fi
done < "$input_file"
</code>

===== [bash] Advanced disk usage script =====

Create a script named disk-usage.sh that reads a number from stdin and displays the partition that has a disk usage percentage greater than that number. \\ If the input received is not a number, use a default threshold value chosen by you.

Usage example:
<code>
$ ./disk-usage.sh
Threshold = 12
WARNING: Partition "/dev/nvme0n1p6" used 13%
WARNING: Partition "/dev/nvme0n1p1" used 27%

$ ./disk-usage.sh
Threshold = ceva
WARNING: Partition "/dev/nvme0n1p6" used 30%
WARNING: Partition "/dev/nvme0n1p1" used 31%
</code>

<code bash disk-usage.sh>
#!/bin/bash

# User should input the threshold
echo "Enter the threshold (percent):"
read threshold

# Check if the threshold is a number
if ! [[ "$threshold" =~ ^[0-9]+$ ]]; then
    echo "Input is not a number, using default threshold: 20."
    threshold=20
else
    echo "Threshold = $threshold"
fi

df -h | awk -v threshold="$threshold" 'NR>1 {gsub(/%/,"",$5); if($5 > threshold) print "WARNING: Partition \""$1"\" used "$5"%"}'
</code>

{{:linux:ubuntu:pasted:20240208-012914.png}}

===== [bash] [sec] [hash] Script to hash two arguments - string =====

Create a script that takes two arguments (strings). The script hash_it.sh concatenates the two arguments and displays their SHA256 hash sum.

<code bash hash_it.sh>
#!/bin/bash

nr_args=$#
 
if [ "$nr_args" -ne 2 ]; then
    echo "Error: two args should be present. Usage: $0 <arg1> <arg2>"
    exit 1
fi

result="$1$2"
echo -n $result | openssl dgst -sha256
</code>
{{:linux:ubuntu:pasted:20240208-022830.png}}

===== [bash] [sec] [hash] Script to read all lines from a file and print the SHA256 sum of each =====

Suppose the input file is called parole.txt.

<code bash hash_it_all.sh>
#!/bin/bash

IFS=$'\n'
while read password; do
    echo -n $password | openssl dgst -sha256 | cut -d '=' -f2 | awk '{print $1}'
done < parole.txt
</code>
{{:linux:ubuntu:pasted:20240208-023728.png}}

===== [bash] [ps] Script to display every second the process with highest CPU usage =====

<code bash top.sh>
#!/bin/bash
while true; do
    clear
    #echo "Update on: $(date)"
    echo "Process with highest CPU usage:"
    ps -eo %cpu,pid,command --sort=-%cpu | head -n 2
    sleep 1
done
</code>
{{:linux:ubuntu:pasted:20240208-030524.png}}

===== [git] Configure initial settings =====

<code>
git config --global user.name "Joe Black"
git config --global user.email "joe.black@github.com"
git config --global init.defaultBranch main
</code>

===== [git] Create an empty local repository in the current directory =====

<code>
git init
</code>
{{:linux:ubuntu:pasted:20240207-020220.png}}

===== [git] Link a local repository with a github one =====

<code>
git remote add origin https://github.com/odefta/array-sorting-algorithms.git
</code>


The sync between the local repo and the remote (github) repo is made with pull (get) and push (put) commands.

===== [git] Check if the remote repo was configured correctly =====

<code>
git remote -v
</code>
{{:linux:ubuntu:pasted:20240207-021555.png}}

===== [git] Get all branches and history from remote repo =====

<code>
git fetch origin
git pull origin main
</code>
{{:linux:ubuntu:pasted:20240207-021840.png}}

===== [git] Get the current branch =====

<code>
git branch --show-current
</code>

<code>
git branch
</code>

<code>
git status
</code>

{{:linux:ubuntu:pasted:20240207-022231.png}}

===== [git] Verify log history =====

<code>
git log
</code>
{{:linux:ubuntu:pasted:20240207-022604.png}}

===== [git] Verify log history - show last commits only =====

Show only the last 4 commits:
<code>
git log -n 4
</code>

Show only the last 4 commits - more compact form:
<code>
git log -n 4 --oneline
</code>

===== [git] Add / commit a file on the current branch to the local repository =====

Create a file, and run git status:
<code>
echo "Hello World" > hello.txt
git status
</code>
{{:linux:ubuntu:pasted:20240207-023225.png}}

We have an untracked file we can add it (in staging area - which is a pre-commit step):
<code>
git add hello.txt
</code>

Use . to add all files (from current dir - which includes sub-dirs).

Now we can commit the hello.txt to the local repo:
<code>
git commit -m "Add hello.txt with hello world"
</code>
m - add a comment

{{:linux:ubuntu:pasted:20240207-023935.png}}

After modifying a file (hello.txt) we can issue again a commit.

===== [git] Push the commit to the remote repo =====

<code>
git push origin main
</code>
{{:linux:ubuntu:pasted:20240207-092707.png}}

===== [git] Adding a new branch =====

<code>
git branch add-gitignore
</code>

Check if the new branch was added:
<code>
git branch
</code>
{{:linux:ubuntu:pasted:20240207-093141.png}}

===== [git] Switch to other branch =====

<code>
git checkout add-gitignore
</code>
{{:linux:ubuntu:pasted:20240207-093658.png}}

Check
<code>
git branch
</code>
{{:linux:ubuntu:pasted:20240207-093737.png}}

===== [git] Merge two branches =====

First, let's commit something to our current branch add-gitignore and sync with the remote:
<code>
echo "*.o" > .gitignore
git add .gitignore
git commit -m "Add .gitignore file"
git push origin add-gitignore
</code>
{{:linux:ubuntu:pasted:20240207-094609.png}}

Now we want to merge our branch main with the add-gitignore branch (to get the .gitignore file).

First, switch to the main branch and get the changes from the remote:
<code>
git checkout main
git pull origin main
</code>
{{:linux:ubuntu:pasted:20240207-094916.png}}

Now we are ready to merge our current branch main with add-gitignore:
<code>
git merge add-gitignore
</code>
{{:linux:ubuntu:pasted:20240207-095041.png}}

Push the changes to the remote:
<code>
git push origin main
</code>
{{:linux:ubuntu:pasted:20240207-095153.png}}

===== [git] Remove a branch both locally and remote =====

We want to delete our secondary branch add-gitignore. \\ 

First, we need to be on another branch (main).
<code>
git checkout main
</code>

Remove local branch.
<code>
git branch -d add-gitignore
</code>
{{:linux:ubuntu:pasted:20240207-095753.png}}

Remove remote branch.
<code>
git push origin --delete add-gitignore
</code>
{{:linux:ubuntu:pasted:20240207-095855.png}}

===== [git] Switch to a remote branch (without creating a local one with the same name) =====

Remote branch is test.

<code>
git fetch origin
git branch -r (verify available remote branches)
git checkout -t origin/test
</code>

===== [user] Check the current user =====

<code>
whoami
</code>
{{:linux:ubuntu:pasted:20240207-115121.png}}

<code>
id
</code>
{{:linux:ubuntu:pasted:20240207-115219.png}}

===== [user] Check another user =====

<code>
sudo id root
</code>
{{:linux:ubuntu:pasted:20240207-115351.png}}

===== [user] Display all logged-in users =====

<code>
who
</code>
{{:linux:ubuntu:pasted:20240207-181234.png}}

To display only the user name:
<code>
who | cut -d ' ' -f1
</code>
{{:linux:ubuntu:pasted:20240207-181335.png}}

To display additional info:
<code>
w
</code>
{{:linux:ubuntu:pasted:20240207-181515.png}}

To filter only the logged-in users:
<code>
w | awk 'FNR>2 {print $1}'
</code>

===== [user] Display the users who have opened a terminal on the host system =====

<code>
who | awk '$2 ~ /^tty/ {print $1}'
</code>

<code>
~ - equals for regular expressions
/ / - delimitates a regular expression
^tty - starts with tty.
</code>

===== [user] Get only the UID for a certain user =====

This will print all info.
<code>
id syslog
</code>
{{:linux:ubuntu:pasted:20240207-115758.png}}

This will print the first column.
<code>
id syslog | awk '{print $1}'
</code>
{{:linux:ubuntu:pasted:20240207-115857.png}}

This will get the uid value after =.
<code>
id syslog | awk '{print $1}' | cut -d= -f2
</code>
{{:linux:ubuntu:pasted:20240207-120000.png}}

Finally, this will get the actual uid value.
<code>
id syslog | awk '{print $1}' | cut -d= -f2 | cut -d'(' -f1
</code>
{{:linux:ubuntu:pasted:20240207-120101.png}}

===== [user] Switch user =====

Switch to another user, you should know only your password. User should be present in sudoers file.
<code>
sudo su <user_name>
</code>

Switch to another user, you should know only your password. 
<code>
sudo su - <user_name>
</code>
- will use the environment variables of that new user.

Switch to another user, you should know the password of the new user.
<code>
su <user_name>
</code>

Switch to another user, simulate initial login (-i).
<code>
sudo -u <user_name> -i
</code>

Start a new login session.
<code>
sudo login <user_name>
</code>

===== [user] Create a new user =====

Simplest and interactive way:
<code>
sudo adduser joe
</code>
{{:linux:ubuntu:pasted:20240207-122120.png}}

We can add the existing user joe to the joegroup:
<code>
sudo adduser joe joegroup
</code>

Advanced, with more options (specify home directory, default shell, default group).
<code>
sudo groupadd joegroup
sudo useradd -m -d /home/joe -s /bin/bash -g joegroup joe
</code>
m - create home directory. \\ 
d - path to the home directory. \\ 
s - set implicit shell. \\ 
g - set primary group.

To add also secondary groups:
<code>
sudo groupadd joesecond
sudo groupadd joethird
sudo useradd -m -d /home/joe -s /bin/bash -g joegroup -G joesecond,joethird joe
</code>
G - secondary groups separated by comma.

Add / change the joe's password:
<code>
sudo passwd joe
</code>

===== [user] Modify an existing user =====

Add secondary groups to the user:
<code>
sudo groupadd joefourth
sudo groupadd joefive
sudo usermod -a -G joefourth,joefive joe
</code>
a - add (important!), without it, the user will be eliminated from the other secondary groups.

{{:linux:ubuntu:pasted:20240207-123705.png}}

Modify the home directory:
<code>
sudo usermod -d /home/newjoe joe
</code>
d - dir name.

Change the joe's default shell (First, inspect the /etc/shells file for a list of all available shells)
<code>
sudo usermod -s /bin/sh joe
</code>
Same effect can be obtained with
<code>
sudo chsh -s /bin/sh joe
</code>

Modify the joe's primary group:
<code>
sudo usermod -g joesecond joe
</code>

===== [user] Remove an user =====

Remove joe, but keep its files.
<code>
sudo userdel joe
</code>

Remove joe with all its files (from home dir and other places).
<code>
sudo userdel -r joe
</code>
r - recursive

===== [user] Block an user to authenticate =====

<code>
sudo usermod -s /usr/sbin/nologin joe
</code>

===== [user] View user details =====

<code>
finger joe
</code>
{{:linux:ubuntu:pasted:20240207-125334.png}}

===== [user] Change mode =====
<note>
read r - 4
write w - 2
execute x - 1
</note>

Owner read and write, group read, other no permission:
<code>
chmod 640 file.txt
chmod u=rw,g=r,o= file.txt
</code>

Add execute right for others:
<code>
chmod 641 file.txt
chmod o+x file.txt
</code>

Eliminate read permission for group:
<code>
chmod 601 file.txt
chmod g-r file.txt
</code>

Eliminate write permission for all:
<code>
chmod ugo-w file.txt
</code>

===== [user] Change owner =====

Change the owner to joe user and joegroup group.
<code>
sudo chown joe:joegroup file.txt
</code>

Change only the owner (let the group intact).
<code>
sudo chown joe file.txt
</code>

Change the owner of all files in a directory (recursive) - let the group intact.
<code>
sudo chown -R joe dir
</code>

Change the owner of all files in a directory (recursive) - change also the group.
<code>
sudo chown -R joe:joegroup dir
</code>

===== [user] Just two users should have right to modify files from a folder =====

Suppose those 2 users are uso and so. Folder path is /uso.

<code>
sudo groupadd usogroup
sudo usermod -aG usogroup uso
sudo usermod -aG usogroup so
sudo chgrp -R usogroup /uso
sudo chmod -R 770 /uso
</code>

===== [user] Generate passwords =====

Generate 5 password of length 10, one per line, each containing at least one uppercase letter.

<code>
for i in {1..5}; do
    echo $(openssl rand -base64 9 | tr -dc 'a-zA-Z0-9' | cut -c 1-9)$(tr -dc 'A-Z' < /dev/urandom | head -c 1)
done
</code>
{{:linux:ubuntu:pasted:20240207-190423.png}}

Same thing using pwgen tool.
<code>
sudo apt install pwgen
</code>

<code>
pwgen -c -n -B 10 5 | tr ' ' '\n'
</code>
c (--capitalize) - at least one capital letter will be included. \\ 
n (--numerals) - at least one number will be included. \\ 
B (--ambiguous) - eliminate ambiguous characters (like 0 and O). \\ 
10 - length of the password. \\ 
5 - generate 5 password.

{{:linux:ubuntu:pasted:20240207-191156.png}}

===== [sec] [base64] Encoding / decoding a string using base64 =====

Encoding.
<code>
echo -n "Base64 is not encryption!" | base64
</code>
QmFzZTY0IGlzIG5vdCBlbmNyeXB0aW9uIQ==

Decoding.
<code>
echo -n "QmFzZTY0IGlzIG5vdCBlbmNyeXB0aW9uIQ==" | base64 -d
</code>
d - decoding \\ 
Base64 is not encryption!

===== [sec] [base64] Encoding / decoding an entire file using base64 =====

Encoding.
<code>
base64 file.txt > file64.txt
</code>

Decoding.
<code>
base64 -d file64.txt > file_dec.txt
</code>

===== [sec] [openssl] Encrypting / decrypting a file using OpenSSL =====

Encrypt the file file.txt to file file.enc
<code>
echo -n "plaintext content" > file.txt
openssl aes-256-cbc -in file.txt -out file.enc -pass pass:"my secret" -pbkdf2 -iter 10000
</code>
aes-256-cbc - encrypt the file using AES-256 in CBC mode \\ 
in - input file (plain text) \\ 
out - output file (encrypted) \\ 
pass - sets the passphrase (will be used for decryption) \\ 
pbkdf2 - selects PBKDF2 for key derivation, enhancing security against brute-force attacks \\ 
iter 10000 - sets the number of iterations in the key derivation, increasing the difficulty of cracking the encryption.

{{:linux:ubuntu:pasted:20240207-132922.png}}

Decrypt the file file.enc to decrypted_file.txt.
<code>
openssl aes-256-cbc -d -in file.enc -out decrypted_file.txt -pass pass:"my secret" -pbkdf2 -iter 10000
</code>
d - decrypt

===== [sec] [hash] Hash a string =====
<note>
Hashing transforms data into a fixed-size string of characters, typically a hash code. This process is useful for verifying data integrity, securely storing passwords, and indexing data in databases. A hash function takes input data and produces a unique hash value; any modification to the data changes the hash significantly.
</note>

Using md5 (less secure) - two ways of achieving the same result.
<code>
echo -n "plaintext content" | md5sum
</code>
f88d6c9eab9c6a2ef3cfd3c59832b4d6  -

<code>
echo -n "plaintext content" | openssl dgst -md5
</code>
MD5(stdin)= f88d6c9eab9c6a2ef3cfd3c59832b4d6

Using SHA256 (much more secure - less collision issues).
<code>
echo -n "plaintext content" | openssl dgst -sha256
</code>
SHA2-256(stdin)= d800efe86c80b6054cff4850f3044d73e979429809f28029e26cd9c4f6d6cea8

===== [sec] [hash] Hash an entire file =====

file.txt content: plaintext content

Using md5.
<code>
md5sum file.txt
</code>
88d6c9eab9c6a2ef3cfd3c59832b4d6  file.txt

Using SHA256.
<code>
sha256sum file.txt
</code>
d800efe86c80b6054cff4850f3044d73e979429809f28029e26cd9c4f6d6cea8  file.txt

===== [sec] [password cracking] Crack linux users passwords using John The Ripper =====

<note tip>
A good dictionary (word list) can be downloaded from here: [[https://github.com/brannondorsey/naive-hashcat/releases/download/data/rockyou.txt|rockyou.txt]]
</note>

Install John The Ripper tool.
<code>
sudo apt install john
</code>

Merge the Linux system files /etc/passwd and /etc/shadow to create a single file (mypasswd.txt) containing user accounts and their hashed passwords.
<code>
sudo unshadow /etc/passwd /etc/shadow > mypasswd.txt
</code>
{{:linux:ubuntu:pasted:20240207-140549.png}}

Create a word list used to guess the password.
<code>
echo -ne "school\nuniversity\nstudent" > wordlist.txt
</code>
n - avoid printing the newline \\ 
e - interpret backslash escapes.

Now we are ready to run John The Ripper.
<code>
john --wordlist=wordlist.txt mypasswd.txt
</code>
{{:linux:ubuntu:pasted:20240207-140923.png}}

Finally, crack the passwords:
<code>
john --format=crypt mypasswd.txt
</code>
{{:linux:ubuntu:pasted:20240207-141340.png}}

View the actual passwords (right after username):
<code>
john --format=crypt mypasswd.txt --show
</code>
{{:linux:ubuntu:pasted:20240207-141509.png}}

===== [sec] [password cracking] Crack a zip archive password using John The Ripper =====

hashfile contains extracted password hashes. \\ 
This will use the default dictionary (word list) file.
<code>
john --format=zip hashfile
</code>

To use a custom dictionary file:
<code>
john --format=zip hashfile --wordlist=path/to/your/wordlist.txt
</code>

===== [sec] [password cracking] Crack a zip archive password using fcrackzip =====

Install the fcrackzip tool.
<code>
sudo apt install fcrackzip 
</code>

Brute-force guessing the password. We know it has 4 characters.
<code>
fcrackzip -v -l 1-4 -u secret_brute_force.zip
</code>
v - verbose \\ 
l 1-4 - pwd length from 1 to 4 \\ 
u - extract the zip archive when the password is found.

Use a dictionary to crack the password.
<code>
fcrackzip -u -D -p wordlist.txt secret.zip
</code>
u - extract the zip archive when the password is found. \\ 
D - enables dictionary mode. \\ 
p - path to the dictionary file.

{{:linux:ubuntu:pasted:20240207-172357.png}}

===== [sec] [hash cracking] Find a hidden message from a file with hashes (one per line) =====

Suppose we have my-hashes.txt:
<code>
F5D6C6C424929713C297514199F7CA41
AAD24C09BF816BBC6EA29C35DF52F896
F95B70FDC3088560732A5AC135644506
6EF5FA162DA08580BF5D1F88520F7388
CBB184DD8E05C9709E5DCAEDAA0495CF
1BC29B36F623BA82AAF6724FD3B16718
</code>

We'll take each line, put it in crackstation.net \\
The decrypted info from each line will form the final message.

{{:linux:ubuntu:pasted:20240207-195601.png}}