Linux è un sistema operativo open source basato sul kernel sviluppato da Linus Torvalds nel 1991. È il sistema più diffuso nei server, negli ambienti cloud, nei dispositivi embedded e in ambito cybersecurity.

• Multiutente e multitasking — più utenti e processi operano contemporaneamente
• Tutto è un file — dispositivi, processi e connessioni di rete sono rappresentati come file
• Permessi e sicurezza — ogni file e processo ha un proprietario e un set di permessi
• Shell come strumento primario — la riga di comando è potente e completamente scriptabile
• Distribuzioni (distro) — esistono decine di varianti adatte a usi diversi

sonica_843@debianotta:~$    # $ = utente normale
root@debianotta:~#          # # = sei root (attenzione!)

Famiglia Debian — usa apt:

apt update                   # aggiorna la lista dei pacchetti
apt upgrade                  # aggiorna tutti i pacchetti installati
apt install nome-pacchetto   # installa un pacchetto
apt remove nome-pacchetto    # rimuove un pacchetto

Famiglia Red Hat — usa dnf:

dnf install nome-pacchetto   # installa un pacchetto
dnf update                   # aggiorna il sistema
dnf remove nome-pacchetto    # rimuove un pacchetto

Percorso assoluto — parte sempre da /: /home/sonica_843/cane

Percorso relativo — parte dalla directory corrente: ../cane

ls *.txt               # tutti i file .txt
ls file?.sh            # file1.sh, file2.sh... (un carattere qualsiasi)
ls ../cane/*           # tutto il contenuto di ../cane/
ls ../*                # tutto il contenuto della directory genitore
cat ~/cane/*.log       # legge tutti i .log nella cartella cane
rm /tmp/test*          # elimina tutto ciò che inizia con 'test' in /tmp
cp ../backup/* .       # copia tutto da ../backup/ nella directory corrente

PATH — lista delle directory in cui la shell cerca i comandi eseguibili.

echo $PATH                         # mostra il PATH corrente
export PATH=$PATH:/nuova/cartella  # aggiunge una cartella al PATH
printenv                           # mostra tutte le variabili d'ambiente
export MIAVAR="valore"             # crea/esporta una variabile
unset MIAVAR                       # elimina una variabile

cut estrae porzioni di testo da ogni riga di un file, operando su campi delimitati o posizioni di carattere.

cat /etc/passwd | cut -d ':' -f 1   # estrae tutti i nomi utente

sed elabora e trasforma testo riga per riga senza aprire un editor interattivo. Fondamentale per sostituzioni in massa e modifica di file di configurazione.

# Sostituire in un file di config con backup di sicurezza:
sed -i.bak 's/porta=80/porta=8080/g' config.txt

# Rimuovere tutte le righe di commento (che iniziano con #):
sed '/^#/d' /etc/ssh/sshd_config

# Visualizzare solo le righe dalla 10 alla 20:
sed -n '10,20p' /var/log/syslog

# Combinare con pipe:
cat /etc/passwd | sed 's/:/  |  /g'

find cerca file e directory secondo criteri precisi: nome, tipo, dimensione, data, permessi, proprietario. È uno degli strumenti più potenti di Linux.

Opzione -exec — eseguire un comando su ogni file trovato:

# Eliminare file .tmp più vecchi di 7 giorni:
find /tmp -name '*.tmp' -mtime +7 -exec rm {} \;

# Cambiare i permessi a tutti gli script .sh trovati:
find ~/scripts -name '*.sh' -exec chmod +x {} \;

# Trovare file di grandi dimensioni:
find / -size +500M -exec ls -lh {} \; 2>/dev/null

# Cercare file con la parola 'password' nel nome:
find / -name '*password*' 2>/dev/null

# Trovare tutti i file modificati oggi:
find . -mtime 0

date mostra o imposta la data e l'ora di sistema. Molto usato negli script per generare timestamp e nomi di file dinamici.

Variabili di formato:

TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
touch backup_${TIMESTAMP}.tar.gz    # es. backup_20260408_143022.tar.gz
echo "$(date +"%d/%m/%Y %T") - Avvio" >> /var/log/mio_script.log

systemctl gestisce i servizi (demoni) su sistemi con systemd. Un servizio è un programma che gira in background: server web, SSH, database, firewall ecc.

sudo systemctl status ssh          # controlla se SSH è attivo
sudo systemctl start ssh           # avvialo se è fermo
sudo systemctl enable ssh          # abilitalo all'avvio automatico
sudo systemctl restart ssh         # riavvialo dopo aver modificato la config
journalctl -u ssh -n 50            # ultime 50 righe di log SSH

SSH (Secure SHell) permette di connettersi a un altro computer in rete in modo sicuro e cifrato. È il protocollo standard per l'amministrazione remota di server Linux.

Autenticazione con chiave — flusso completo:

# 1. Genera le chiavi (una sola volta):
ssh-keygen -t rsa -b 4096
# Crea: ~/.ssh/id_rsa (privata) e ~/.ssh/id_rsa.pub (pubblica)

# 2. Copia la chiave pubblica sul server:
ssh-copy-id sonica_843@192.168.1.10

# 3. Da ora puoi connetterti senza password:
ssh sonica_843@192.168.1.10

Il file /etc/ssh/sshd_config — parametri importanti:

Port 22                    # porta di ascolto
PermitRootLogin no         # IMPORTANTE: disabilitare login diretto come root
PasswordAuthentication no  # usare solo chiavi, non password
AllowUsers sonica_843      # permettere solo utenti specifici
# Dopo ogni modifica:
sudo systemctl restart ssh

cat ~/.bash_history     # il file della cronologia
 comando_segreto        # uno spazio iniziale = non viene registrato in history

In Linux esiste un unico superutente chiamato root (UID 0). Ha accesso illimitato a tutto il sistema.

sonica_843@debianotta:~$    # $ = utente normale
root@debianotta:~#          # # = sei root (attenzione!)

Metodo 1 — sudo (raccomandato):

sudo comando              # esegue come root
sudo apt update
sudo -l                   # mostra cosa puoi fare con sudo
sudo -k                   # invalida subito il token sudo

Metodo 2 — sudo -i oppure sudo su - (shell root completa):

sudo -i                   # apre shell root con ambiente di root
sudo su -                 # equivalente
exit                      # torna all'utente normale

Metodo 3 — su (switch user):

su                        # diventa root (richiede password di root)
su -                      # diventa root con ambiente completo (consigliato)
su nomeutente             # diventa un altro utente
su - nomeutente           # con il suo ambiente

sudo visudo               # modifica /etc/sudoers in modo sicuro

mario   ALL=(ALL:ALL) ALL          # mario può fare tutto
mario   ALL=(ALL) /usr/bin/apt     # mario può usare solo apt
mario   ALL=(ALL) NOPASSWD: ALL    # senza password

usermod -aG sudo mario             # aggiunge mario al gruppo sudo

Struttura del file /etc/passwd:

sonica_843 : x : 1001 : 1001 : Sonica : /home/sonica_843 : /bin/bash
#    (1)    (2)  (3)    (4)     (5)            (6)               (7)
# (1) nome  (2) password in /etc/shadow  (3) UID  (4) GID
# (5) info opzionali  (6) home directory  (7) shell di default

Leggere i permessi con ls -l:

-rwxr-xr--  1  sonica_843  staff  4096  Mar 19  script.sh
 |└──┴──┴──┘
 |  u   g   o
 └─ tipo: - = file, d = directory, l = link simbolico

chmod — cambiare i permessi:

chmod 755 script.sh    # rwxr-xr-x
chmod 644 config.txt   # rw-r--r--
chmod 600 chiave.pem   # rw-------
chmod +x script.sh     # aggiunge esecuzione a tutti
chmod u+x script.sh    # aggiunge esecuzione solo al proprietario

chown — cambiare proprietario:

sudo chown sonica_843 orario.sh              # cambia proprietario
sudo chown sonica_843:sonica_843 orario.sh   # cambia proprietario e gruppo
sudo chown -R sonica_843:sonica_843 ~/cane/  # ricorsivo su tutta la cartella

# Caso pratico — file creato da root, non modificabile da sonica_843:
sudo chown sonica_843:sonica_843 orario.sh
chmod +x orario.sh
./orario.sh

#!/bin/bash
# ATTENZIONE: non deve esserci nulla prima di #! — nemmeno un apice.
echo "Inizio dello script"

chmod +x mio_script.sh   # rende eseguibile
./mio_script.sh          # esegue lo script

Le variabili memorizzano valori di testo o numeri. Non richiedono dichiarazione. Regola fondamentale: nessuno spazio attorno al segno =.

#!/bin/bash
# Assegnare un valore (NO spazi attorno a =)
NOME="Sonica"
ETA=30

# Leggere una variabile: si usa $ davanti al nome
echo $NOME              # stampa: Sonica
echo "Hai $ETA anni"    # stampa: Hai 30 anni
echo "${NOME}_backup"   # le graffe delimitano il nome: Sonica_backup

# Catturare l'output di un comando
DATA=$(date +"%Y-%m-%d")   # sintassi moderna (consigliata)
KERNEL=`uname -r`           # sintassi vecchia (equivalente)

# Operazioni aritmetiche
A=10; B=3
SOMMA=$((A + B))         # risultato: 13
PRODOTTO=$((A * B))      # risultato: 30

# Variabili speciali di Bash
echo $0    # nome dello script
echo $1    # primo argomento passato allo script
echo $#    # numero di argomenti passati
echo $?    # codice di uscita dell'ultimo comando (0 = successo)
echo $$    # PID del processo corrente

#!/bin/bash
# Uso: ./saluta.sh Mario 25
NOME=$1; ETA=$2
if [ -z "$NOME" ]; then
    echo "Errore: fornisci un nome. Uso: $0 <nome> <eta>"
    exit 1
fi
echo "Ciao $NOME, hai $ETA anni!"

Un array è una variabile che contiene più valori, accessibili tramite un indice numerico che parte da 0.

Array indicizzati:

#!/bin/bash
FRUTTI=("mela" "banana" "arancia" "pera")

echo ${FRUTTI[0]}       # mela
echo ${FRUTTI[2]}       # arancia
echo ${FRUTTI[@]}       # tutti gli elementi
echo ${#FRUTTI[@]}      # 4 (numero elementi)

FRUTTI+=("kiwi")        # aggiunge un elemento
FRUTTI[1]="mango"       # modifica un elemento
unset FRUTTI[2]         # elimina un elemento
echo ${FRUTTI[@]:1:3}   # slice: dal 2°, prende 3 elementi

Iterare su un array con for:

#!/bin/bash
UTENTI=("mario" "luigi" "sonica_843" "root")

for UTENTE in "${UTENTI[@]}"; do
    echo "Elaboro utente: $UTENTE"
done

# Iterare con indice:
for i in "${!UTENTI[@]}"; do
    echo "Indice $i: ${UTENTI[$i]}"
done

# Array dai file nella directory:
FILE_TXT=(*.txt)
echo "Trovati ${#FILE_TXT[@]} file .txt"

Array associativi (dizionari):

#!/bin/bash
declare -A UTENTE          # dichiarazione obbligatoria

UTENTE["nome"]="Sonica"
UTENTE["eta"]="30"
UTENTE["shell"]="/bin/bash"
UTENTE["home"]="/home/sonica_843"

echo ${UTENTE["nome"]}     # Sonica
echo ${!UTENTE[@]}          # tutte le chiavi

for CHIAVE in "${!UTENTE[@]}"; do
    echo "$CHIAVE = ${UTENTE[$CHIAVE]}"
done

read -p "Come ti chiami? " NOME
read -sp "Password: " PASS      # -s = silent (nasconde l'input)
echo "Ciao $NOME!"

if [ $NUM -gt 10 ]; then
    echo "Maggiore di 10"
elif [ $NUM -eq 10 ]; then
    echo "Esattamente 10"
else
    echo "Minore di 10"
fi

# Intervallo numerico
for i in {1..5}; do
    echo "Contatore: $i"
done

# File con wildcard
for FILE in *.txt; do
    echo "Elaboro: $FILE"
done

# Array
for FRUTTO in "${FRUTTI[@]}"; do
    echo "$FRUTTO"
done

#!/bin/bash
# Script: gestione_utenti.sh

UTENTI=("mario" "luigi" "sonica_843")

echo "=== Controllo utenti ==="

for UTENTE in "${UTENTI[@]}"; do
    if id "$UTENTE" &>/dev/null; then
        echo "[OK] $UTENTE esiste — $(id $UTENTE)"
    else
        echo "[--] $UTENTE non trovato"
    fi
done

echo "Fatto il $(date +"%d/%m/%Y %T")"

netstat mostra connessioni attive, tabelle di routing e statistiche. Nelle versioni moderne è sostituito da ss (più veloce).

netstat -tulnp | grep :80    # trova quale processo usa la porta 80
ss -tulnp | grep :443        # stesso per la porta HTTPS

nmap è lo strumento standard per la scansione di reti e host. Usarlo solo su sistemi di cui si ha autorizzazione.

sudo nmap -A -p- 192.168.1.100    # scansione completa
nmap -sn 192.168.1.0/24           # host attivi sulla rete locale

Una raccolta di script Bash realizzati durante lo stage formativo del Progetto GOL — Garanzia di Occupabilità dei Lavoratori, percorso CyberSecurity. Terminale interattivo con esecuzione simulata, codice sorgente commentato e documentazione.

Tecnologie usate: grep · bc · tr · cut · shuf · /dev/urandom