How-To-Secure-A-Linux-Server — Guida passo-passo per l'hardening di un server Linux, che copre la sicurezza SSH, i firewall, il rilevamento delle intrusioni, l'auditing e la configurazione del sistema per ridurre la superficie di attacco e migliorare la difesa. | Kitploit

5. Modifica tutte le variabili in *group_vars/variables.yml* secondo le tue esigenze.
6. Abilita l'accesso SSH come root prima di eseguire i playbook:  ```
nano /etc/ssh/sshd_config
[...]
PermitRootLogin yes
[...]

Dal computer che utilizzerai per connetterti al tuo server, il client, non il server stesso, crea una chiave Ed25519 con ssh-keygen:

ssh-keygen -t ed25519

Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519):
Created directory '/home/user/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_ed25519.
Your public key has been saved in /home/user/.ssh/id_ed25519.pub.
The key fingerprint is:
SHA256:F44D4dr2zoHqgj0i2iVIHQ32uk/Lx4P+raayEAQjlcs user@client
The key's randomart image is:
+--[ED25519 256]--+
|xxxx  x          |
|o.o +. .         |
| o o oo   .      |
|. E oo . o .     |
| o o. o S o      |
|... .. o o       |
|.+....+ o        |
|+.=++o.B..       |
|+..=**=o=.       |
+----[SHA256]-----+

Nota: Se imposti una passphrase, dovrai inserirla ogni volta che ti connetti al tuo server usando questa chiave, a meno che tu non stia usando ssh-agent.

Ora devi aggiungere la chiave pubblica ~/.ssh/id_ed25519.pub dal tuo client al file ~/.ssh/authorized_keys sul tuo server. Poiché presumibilmente siamo ancora a casa sulla LAN, probabilmente siamo al sicuro da attacchi MIM, quindi useremo ssh-copy-id per trasferire e aggiungere la chiave pubblica:

ssh-copy-id user@server

/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/id_ed25519.pub"
The authenticity of host 'host (192.168.1.96)' can't be established.
ECDSA key fingerprint is SHA256:QaDQb/X0XyVlogh87sDXE7MR8YIK7ko4wS5hXjRySJE.
Are you sure you want to continue connecting (yes/no)? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
user@host's password:

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'user@host'"
and check to make sure that only the key(s) you wanted were added.

Crea un gruppo:
```
sudo groupadd sshusers
```
Aggiungi account al gruppo:
```
sudo usermod -a -G sshusers user1
sudo usermod -a -G sshusers user2
sudo usermod -a -G sshusers ...
```
Dovrai farlo per ogni account sul tuo server che necessita di accesso SSH.

Fai una copia di backup del file di configurazione del server OpenSSH /etc/ssh/sshd_config e rimuovi i commenti per renderlo più facile da leggere:
```
sudo cp --archive /etc/ssh/sshd_config /etc/ssh/sshd_config-COPY-$(date +"%Y%m%d%H%M%S")
sudo sed -i -r -e '/^#|^$/ d' /etc/ssh/sshd_config
```

Modifica /etc/ssh/sshd_config quindi trova e modifica o aggiungi queste impostazioni che dovrebbero essere applicate indipendentemente dalla tua configurazione/setup:

Nota: SSH non gradisce impostazioni duplicate contraddittorie. Ad esempio, se hai ChallengeResponseAuthentication no e poi ChallengeResponseAuthentication yes, SSH rispetterà la prima e ignorerà la seconda. Il tuo file /etc/ssh/sshd_config potrebbe già contenere alcune delle impostazioni/righe seguenti. Per evitare problemi, dovrai esaminare manualmente il tuo file /etc/ssh/sshd_config e risolvere eventuali impostazioni duplicate contraddittorie.

Nota: Se stai eseguendo OpenSSH 9.1 o successivo, decommenta la riga RequiredRSASize 3072 nella configurazione seguente. Questo impone una dimensione minima della chiave RSA di 3072 bit e rifiuterà chiavi RSA più piccole durante l'autenticazione. Questo riguarda solo le chiavi RSA. Se usi chiavi ED25519 o ECDSA, non sei interessato. Puoi controllare il tipo e la dimensione della tua chiave con ssh-keygen -l -f ~/.ssh/id_rsa. Nelle versioni precedenti di OpenSSH, lascia la riga commentata poiché impedirebbe l'avvio di sshd.

########################################################################################################
# start settings from https://infosec.mozilla.org/guidelines/openssh#modern-openssh-67 as of 2019-01-01
########################################################################################################

# Supported HostKey algorithms by order of preference.
HostKey /etc/ssh/ssh_host_ed25519_key
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key

KexAlgorithms [email protected],ecdh-sha2-nistp521,ecdh-sha2-nistp384,ecdh-sha2-nistp256,diffie-hellman-group-exchange-sha256

Ciphers [email protected],[email protected],[email protected],aes256-ctr,aes192-ctr,aes128-ctr

MACs [email protected],[email protected],hmac-sha2-512,hmac-sha2-256,[email protected]

# LogLevel VERBOSE logs user's key fingerprint on login. Needed to have a clear audit track of which key was using to log in.
LogLevel VERBOSE

# Use kernel sandbox mechanisms where possible in unprivileged processes
# Systrace on OpenBSD, Seccomp on Linux, seatbelt on MacOSX/Darwin, rlimit elsewhere.
# Note: This setting is deprecated in OpenSSH 7.5 (https://www.openssh.com/txt/release-7.5)
# UsePrivilegeSeparation sandbox

########################################################################################################
# end settings from https://infosec.mozilla.org/guidelines/openssh#modern-openssh-67 as of 2019-01-01
########################################################################################################

# don't let users set environment variables
PermitUserEnvironment no

# Log sftp level file access (read/write/etc.) that would not be easily logged otherwise.
Subsystem sftp  internal-sftp -f AUTHPRIV -l INFO

# disable X11 forwarding as X11 is very insecure
# you really shouldn't be running X on a server anyway
X11Forwarding no

# disable port forwarding
AllowTcpForwarding no
AllowStreamLocalForwarding no
GatewayPorts no
PermitTunnel no

# don't allow login if the account has an empty password
PermitEmptyPasswords no

# ignore .rhosts and .shosts
IgnoreRhosts yes

# verify hostname matches IP
UseDNS yes

Compression no

# TCP keepalive is spoofable (runs outside the encrypted channel)
# Use ClientAlive instead (runs inside the encrypted channel)
TCPKeepAlive no

AllowAgentForwarding no
PermitRootLogin no

# don't allow .rhosts or /etc/hosts.equiv
HostbasedAuthentication no

# OpenSSH 9.1 and later
# Enforce a minimum RSA key size of 3072 bits
# https://www.keylength.com/en/compare/
# RequiredRSASize 3072

# https://github.com/imthenachoman/How-To-Secure-A-Linux-Server/issues/115
HashKnownHosts yes

Poi trova e modifica o aggiungi queste impostazioni e imposta i valori secondo i tuoi requisiti:
Assicurati che non ci siano impostazioni duplicate che si contraddicono a vicenda. Il comando seguente non dovrebbe produrre alcun output.
```
awk 'NF && $1!~/^(#|HostKey)/{print $1}' /etc/ssh/sshd_config | sort | uniq -c | grep -v ' 1 '
```
Riavvia ssh:
```
sudo service sshd restart
```

Puoi verificare che le configurazioni abbiano funzionato con sshd -T e controllare l'output:

sudo sshd -T

port 22
addressfamily any
listenaddress [::]:22
listenaddress 0.0.0.0:22
usepam yes
logingracetime 30
x11displayoffset 10
maxauthtries 2
maxsessions 2
clientaliveinterval 15
clientalivecountmax 3
streamlocalbindmask 0177
permitrootlogin no
ignorerhosts yes
ignoreuserknownhosts no
hostbasedauthentication no
...
subsystem sftp internal-sftp -f AUTHPRIV -l INFO
maxstartups 2:30:2
permittunnel no
ipqos lowdelay throughput
rekeylimit 0 0
permitopen any

Fai una copia di backup del file dei moduli di SSH /etc/ssh/moduli:
```
sudo cp --archive /etc/ssh/moduli /etc/ssh/moduli-COPY-$(date +"%Y%m%d%H%M%S")
```

Rimuovi i moduli corti:

sudo awk '$5 >= 3071' /etc/ssh/moduli | sudo tee /etc/ssh/moduli.tmp
sudo mv /etc/ssh/moduli.tmp /etc/ssh/moduli

Installa libpam-google-authenticator.

Su sistemi basati su Debian:
```
sudo apt install libpam-google-authenticator
```

Assicurati di aver effettuato l'accesso con l'ID per cui vuoi abilitare 2FA/MFA ed esegui google-authenticator per creare i dati del token necessari:

google-authenticator

Do you want authentication tokens to be time-based (y/n) y
https://www.google.com/chart?chs=200x200&chld=M|0&cht=qr&chl=otpauth://totp/user@host%3Fsecret%3DR4ZWX34FQKZROVX7AGLJ64684Y%26issuer%3Dhost

...

Your new secret key is: R3NVX3FFQKZROVX7AGLJUGGESY
Your verification code is 751419
Your emergency scratch codes are:
  12345678
  90123456
  78901234
  56789012
  34567890

Do you want me to update your "/home/user/.google_authenticator" file (y/n) y

Do you want to disallow multiple uses of the same authentication
token? This restricts you to one login about every 30s, but it increases
your chances to notice or even prevent man-in-the-middle attacks (y/n) Do you want to disallow multiple uses of the same authentication
token? This restricts you to one login about every 30s, but it increases
your chances to notice or even prevent man-in-the-middle attacks (y/n) y

By default, tokens are good for 30 seconds. In order to compensate for
possible time-skew between the client and the server, we allow an extra
token before and after the current time. If you experience problems with
poor time synchronization, you can increase the window from its default
size of +-1min (window size of 3) to about +-4min (window size of
17 acceptable tokens).
Do you want to do so? (y/n) y

If the computer that you are logging into isn't hardened against brute-force
login attempts, you can enable rate-limiting for the authentication module.
By default, this limits attackers to no more than 3 login attempts every 30s.
Do you want to enable rate-limiting (y/n) y

Nota: questo non va eseguito come root.

Seleziona l'opzione predefinita (y nella maggior parte dei casi) per tutte le domande e ricordati di salvare i codici di emergenza.

Esegui un backup del file di configurazione PAM di SSH /etc/pam.d/sshd:
```
sudo cp --archive /etc/pam.d/sshd /etc/pam.d/sshd-COPY-$(date +"%Y%m%d%H%M%S")
```

Ora dobbiamo abilitarlo come metodo di autenticazione per SSH aggiungendo questa riga a /etc/pam.d/sshd:

auth       required     pam_google_authenticator.so nullok

Nota: Controlla qui per sapere cosa significa nullok.

Per i pigri:

echo -e "\nauth       required     pam_google_authenticator.so nullok         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")" | sudo tee -a /etc/pam.d/sshd

Dì a SSH di utilizzarlo aggiungendo o modificando questa riga in /etc/ssh/sshd_config:

ChallengeResponseAuthentication yes

Per i pigri:

sudo sed -i -r -e "s/^(challengeresponseauthentication .*)$/# \1         # commented by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")/I" /etc/ssh/sshd_config
echo -e "\nChallengeResponseAuthentication yes         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")" | sudo tee -a /etc/ssh/sshd_config

Riavvia ssh:
```
sudo service sshd restart
```

La tua installazione potrebbe aver già fatto questo, o potrebbe già avere un gruppo speciale destinato a questo scopo, quindi controlla prima.
- Debian crea il gruppo sudo. Per visualizzare gli utenti che fanno parte di questo gruppo (quindi con privilegi sudo):
```
cat /etc/group | grep "sudo"
```
- RedHat crea il gruppo wheel
Vedi https://github.com/imthenachoman/How-To-Secure-A-Linux-Server/issues/39 per una nota su alcune distribuzioni che fanno sì che sudo non richieda una password. Grazie a sbrl per la condivisione.

Crea un gruppo:
```
sudo groupadd sudousers
```
Aggiungi account al gruppo:
```
sudo usermod -a -G sudousers user1
sudo usermod -a -G sudousers user2
sudo usermod -a -G sudousers  ...
```
Dovrai farlo per ogni account sul tuo server che necessita di privilegi sudo.
Esegui un backup del file di configurazione di sudo /etc/sudoers:
```
sudo cp --archive /etc/sudoers /etc/sudoers-COPY-$(date +"%Y%m%d%H%M%S")
```
Modifica il file di configurazione di sudo /etc/sudoers:
```
sudo visudo
```
Dì a sudo di consentire solo agli utenti nel gruppo sudousers di usare sudo aggiungendo questa riga se non è già presente:
```
%sudousers   ALL=(ALL:ALL) ALL
```

Crea un gruppo:
```
sudo groupadd suusers
```
Aggiungi account al gruppo:
```
sudo usermod -a -G suusers user1
sudo usermod -a -G suusers user2
sudo usermod -a -G suusers  ...
```
Dovrai farlo per ogni account sul tuo server che necessita di privilegi sudo.
Fai in modo che solo gli utenti in questo gruppo possano eseguire /bin/su:
```
sudo dpkg-statoverride --update --add root suusers 4750 /bin/su
```

Installa il software:
```
sudo apt install firejail firejail-profiles
```
Nota: per Debian 10 Stable, è consigliato il backport ufficiale:
```
sudo apt install -t buster-backports firejail firejail-profiles
```

Consenti a un'applicazione (installata in /usr/bin o /bin) di essere eseguita solo in una sandbox (vedi alcuni esempi qui sotto):

sudo ln -s /usr/bin/firejail /usr/local/bin/google-chrome-stable
sudo ln -s /usr/bin/firejail /usr/local/bin/firefox
sudo ln -s /usr/bin/firejail /usr/local/bin/chromium
sudo ln -s /usr/bin/firejail /usr/local/bin/evolution
sudo ln -s /usr/bin/firejail /usr/local/bin/thunderbird

Esegui l'applicazione come al solito (tramite terminale o launcher) e verifica se è in esecuzione in una gabbia:
```
firejail --list
```
Consenti a un'app in sandbox di essere eseguita di nuovo come prima (esempio: firefox)
```
sudo rm /usr/local/bin/firefox
```

Abilita la sincronizzazione NTP:
```
sudo timedatectl set-ntp true
```
Verifica che funzioni:
```
timedatectl status
```
Dovresti vedere NTP service: active e System clock synchronized: yes nell'output.

Configura i server NTP attendibili. Esegui un backup del file di configurazione e poi modificalo:

sudo cp --archive /etc/systemd/timesyncd.conf /etc/systemd/timesyncd.conf-COPY-$(date +"%Y%m%d%H%M%S")

Modifica /etc/systemd/timesyncd.conf e decommenta/imposta la sezione [Time]:

[Time]
NTP=pool.ntp.org
FallbackNTP=0.debian.pool.ntp.org 1.debian.pool.ntp.org 2.debian.pool.ntp.org

Per i pigri:

sudo sed -i -r -e "s/^#?NTP=.*$/NTP=pool.ntp.org         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")/" /etc/systemd/timesyncd.conf
sudo sed -i -r -e "s/^#?FallbackNTP=.*$/FallbackNTP=0.debian.pool.ntp.org 1.debian.pool.ntp.org 2.debian.pool.ntp.org         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")/" /etc/systemd/timesyncd.conf

Riavvia il servizio per applicare le modifiche:
```
sudo systemctl restart systemd-timesyncd
```

Controlla lo stato della sincronizzazione:

timedatectl timesync-status

       Server: 108.61.56.35 (pool.ntp.org)
Poll interval: 32s (min: 32s; max: 34min 8s)
         Leap: normal
      Version: 4
      Stratum: 2
    Reference: C342F10A
    Precision: 1us (2^0)
 Root distance: 24.054ms (max: 5s)
       Offset: +2.156ms
        Delay: 48.567ms
       Jitter: 1.452ms
 Packet count: 3

Installa ntp.

Su sistemi basati su Debian:
```
sudo apt install ntp
```
Esegui un backup del file di configurazione del client NTP /etc/ntp.conf:
```
sudo cp --archive /etc/ntp.conf /etc/ntp.conf-COPY-$(date +"%Y%m%d%H%M%S")
```

La configurazione predefinita, almeno su Debian, è già abbastanza sicura. L'unica cosa di cui vogliamo assicurarci è di utilizzare la direttiva pool e non direttive server. La direttiva pool consente al client NTP di smettere di usare un server se non risponde o fornisce un'ora errata. Fallo commentando tutte le direttive server e aggiungendo quanto segue a /etc/ntp.conf.

pool pool.ntp.org iburst

Per i pigri:

sudo sed -i -r -e "s/^((server|pool).*)/# \1         # commented by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")/" /etc/ntp.conf
echo -e "\npool pool.ntp.org iburst         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")" | sudo tee -a /etc/ntp.conf

Esempio /etc/ntp.conf:

driftfile /var/lib/ntp/ntp.drift
statistics loopstats peerstats clockstats
filegen loopstats file loopstats type day enable
filegen peerstats file peerstats type day enable
filegen clockstats file clockstats type day enable
restrict -4 default kod notrap nomodify nopeer noquery limited
restrict -6 default kod notrap nomodify nopeer noquery limited
restrict 127.0.0.1
restrict ::1
restrict source notrap nomodify noquery
pool pool.ntp.org iburst         # added by user on 2019-03-09 @ 10:23:35

Riavvia ntp:
```
sudo service ntp restart
```

Controlla lo stato del servizio ntp:

sudo systemctl status ntp

● ntp.service - LSB: Start NTP daemon
   Loaded: loaded (/etc/init.d/ntp; generated; vendor preset: enabled)
   Active: active (running) since Sat 2019-03-09 15:19:46 EST; 4s ago
     Docs: man:systemd-sysv-generator(8)
  Process: 1016 ExecStop=/etc/init.d/ntp stop (code=exited, status=0/SUCCESS)
  Process: 1028 ExecStart=/etc/init.d/ntp start (code=exited, status=0/SUCCESS)
    Tasks: 2 (limit: 4915)
   CGroup: /system.slice/ntp.service
           └─1038 /usr/sbin/ntpd -p /var/run/ntpd.pid -g -u 108:113

Mar 09 15:19:46 host ntpd[1038]: Listen and drop on 0 v6wildcard [::]:123
Mar 09 15:19:46 host ntpd[1038]: Listen and drop on 1 v4wildcard 0.0.0.0:123
Mar 09 15:19:46 host ntpd[1038]: Listen normally on 2 lo 127.0.0.1:123
Mar 09 15:19:46 host ntpd[1038]: Listen normally on 3 enp0s3 10.10.20.96:123
Mar 09 15:19:46 host ntpd[1038]: Listen normally on 4 lo [::1]:123
Mar 09 15:19:46 host ntpd[1038]: Listen normally on 5 enp0s3 [fe80::a00:27ff:feb6:ed8e%2]:123
Mar 09 15:19:46 host ntpd[1038]: Listening on routing socket on fd #22 for interface updates
Mar 09 15:19:47 host ntpd[1038]: Soliciting pool server 108.61.56.35
Mar 09 15:19:48 host ntpd[1038]: Soliciting pool server 69.89.207.199
Mar 09 15:19:49 host ntpd[1038]: Soliciting pool server 45.79.111.114

Controlla lo stato di ntp:

sudo ntpq -p

     remote           refid      st t when poll reach   delay   offset  jitter
==============================================================================
 pool.ntp.org    .POOL.          16 p    -   64    0    0.000    0.000   0.000
*lithium.constan 198.30.92.2      2 u    -   64    1   19.900    4.894   3.951
 ntp2.wiktel.com 212.215.1.157    2 u    2   64    1   48.061   -0.431   0.104

Esegui un backup di /etc/fstab:

sudo cp --archive /etc/fstab /etc/fstab-COPY-$(date +"%Y%m%d%H%M%S")

Aggiungi questa riga a /etc/fstab per montare /proc con hidepid=2:

proc     /proc     proc     defaults,hidepid=2     0     0

Per i pigri:

echo -e "\nproc     /proc     proc     defaults,hidepid=2     0     0         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")" | sudo tee -a /etc/fstab

Riavvia il sistema:
```
sudo reboot now
```
Nota: In alternativa, puoi rimontare /proc senza riavviare con sudo mount -o remount,hidepid=2 /proc

Installare libpam-pwquality.

Su sistemi basati su Debian:
```
sudo apt install libpam-pwquality
```
Fare un backup del file di configurazione delle password di PAM /etc/pam.d/common-password:
```
sudo cp --archive /etc/pam.d/common-password /etc/pam.d/common-password-COPY-$(date +"%Y%m%d%H%M%S")
```
Dire a PAM di usare libpam-pwquality per imporre password robuste modificando il file /etc/pam.d/common-password e cambiare la riga che inizia così:
```
password        requisite                       pam_pwquality.so
```
a questa:
```
password        requisite                       pam_pwquality.so retry=3 minlen=10 difok=3 ucredit=-1 lcredit=-1 dcredit=-1 ocredit=-1 maxrepeat=3 gecoschec
```
Le opzioni sopra sono:
- retry=3 = richiedere all'utente 3 volte prima di restituire un errore.
- minlen=10 = la lunghezza minima della password, tenendo conto di eventuali crediti (o debiti) da questi:
  - dcredit=-1 = deve avere almeno una cifra
  - ucredit=-1 = deve avere almeno una lettera maiuscola
  - lcredit=-1 = deve avere almeno una lettera minuscola
  - ocredit=-1 = deve avere almeno un carattere non alfanumerico
- difok=3 = almeno 3 caratteri della nuova password non devono essere presenti nella vecchia password
- maxrepeat=3 = consentire un massimo di 3 caratteri ripetuti
- gecoschec = non consentire password con il nome dell'account
Per i pigri:
```
sudo sed -i -r -e "s/^(password\s+requisite\s+pam_pwquality.so)(.*)$/# \1\2         # commented by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")\n\1 retry=3 minlen=10 difok=3 ucredit=-1 lcredit=-1 dcredit=-1 ocredit=-1 maxrepeat=3 gecoschec         # added by $(whoami) on $(date +"%Y-%m-%d @ %H:%M:%S")/" /etc/pam.d/common-password
```

Installare unattended-upgrades, apt-listchanges e apticron:
```
sudo apt install unattended-upgrades apt-listchanges apticron
```

Ora dobbiamo configurare unattended-upgrades per applicare automaticamente gli aggiornamenti. Questo viene solitamente fatto modificando i file /etc/apt/apt.conf.d/20auto-upgrades e /etc/apt/apt.conf.d/50unattended-upgrades creati dai pacchetti. Tuttavia, poiché questi file potrebbero essere sovrascritti in un futuro aggiornamento, creeremo invece un nuovo file. Crea il file /etc/apt/apt.conf.d/51myunattended-upgrades e aggiungi questo:

// Enable the update/upgrade script (0=disable)
APT::Periodic::Enable "1";

// Do "apt-get update" automatically every n-days (0=disable)
APT::Periodic::Update-Package-Lists "1";

// Do "apt-get upgrade --download-only" every n-days (0=disable)
APT::Periodic::Download-Upgradeable-Packages "1";

// Do "apt-get autoclean" every n-days (0=disable)
APT::Periodic::AutocleanInterval "7";

// Send report mail to root
//     0:  no report             (or null string)
//     1:  progress report       (actually any string)
//     2:  + command outputs     (remove -qq, remove 2>/dev/null, add -d)
//     3:  + trace on    APT::Periodic::Verbose "2";
APT::Periodic::Unattended-Upgrade "1";

// Automatically upgrade packages from these
Unattended-Upgrade::Origins-Pattern {
      "o=Debian,a=stable";
      "o=Debian,a=stable-updates";
      "origin=Debian,codename=${distro_codename},label=Debian-Security";
};

// You can specify your own packages to NOT automatically upgrade here
Unattended-Upgrade::Package-Blacklist {
};

// Run dpkg --force-confold --configure -a if a unclean dpkg state is detected to true to ensure that updates get installed even when the system got interrupted during a previous run
Unattended-Upgrade::AutoFixInterruptedDpkg "true";

//Perform the upgrade when the machine is running because we wont be shutting our server down often
Unattended-Upgrade::InstallOnShutdown "false";

// Send an email to this address with information about the packages upgraded.
Unattended-Upgrade::Mail "root";

// Always send an e-mail
Unattended-Upgrade::MailOnlyOnError "false";

// Remove all unused dependencies after the upgrade has finished
Unattended-Upgrade::Remove-Unused-Dependencies "true";

// Remove any new unused dependencies after the upgrade has finished
Unattended-Upgrade::Remove-New-Unused-Dependencies "true";

// Automatically reboot WITHOUT CONFIRMATION if the file /var/run/reboot-required is found after the upgrade.
Unattended-Upgrade::Automatic-Reboot "true";

// Automatically reboot even if users are logged in.
Unattended-Upgrade::Automatic-Reboot-WithUsers "true";

Note:

Controlla /usr/lib/apt/apt.systemd.daily per dettagli sulle opzioni APT::Periodic
Controlla https://github.com/mvo5/unattended-upgrades per dettagli sulle opzioni Unattended-Upgrade

Eseguire una simulazione (dry-run) di unattended-upgrades per assicurarsi che il file di configurazione sia corretto:
```
sudo unattended-upgrade -d --dry-run
```
Se tutto è a posto, puoi lasciarlo eseguire quando è programmato o forzare un'esecuzione con unattended-upgrade -d.
Configurare apt-listchanges a proprio piacimento:
```
sudo dpkg-reconfigure apt-listchanges
```
Per apticron, le impostazioni predefinite sono sufficienti, ma puoi controllarle in /etc/apticron/apticron.conf se vuoi cambiarle. Ad esempio, la mia configurazione è così:
```
EMAIL="root"
NOTIFY_NO_UPDATES="1"
```

Installare rng-tools.

Su sistemi basati su Debian:
```
sudo apt-get install rng-tools
```
Ora dobbiamo impostare il dispositivo hardware utilizzato per generare numeri casuali aggiungendo questo a /etc/default/rng-tools:
```
HRNGDEVICE=/dev/urandom
```
Per i pigri:
```
echo "HRNGDEVICE=/dev/urandom" | sudo tee -a /etc/default/rng-tools
```

Riavviare il servizio:

sudo systemctl stop rng-tools.service
sudo systemctl start rng-tools.service

Testare la casualità:
- https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/security_guide/sect-security_guide-encryption-using_the_random_number_generator
- https://wiki.archlinux.org/index.php/Rng-tools

([Table of Contents](#table-of-contents))

## La Rete

### Firewall con UFW (Uncomplicated Firewall)

#### Perché

Chiamatemi paranoico, e non siete obbligati a essere d'accordo, ma voglio negare tutto il traffico in entrata e in uscita dal mio server tranne quello che autorizzo esplicitamente. Perché il mio server dovrebbe inviare traffico in uscita di cui non sono a conoscenza? E perché il traffico esterno dovrebbe tentare di accedere al mio server se non so chi o cosa sia? Quando si parla di buona sicurezza, la mia opinione è di rifiutare/negare per impostazione predefinita e permettere per eccezione.

Ovviamente, se non siete d'accordo, va benissimo e potete configurare UFW secondo le vostre esigenze.

In ogni caso, assicurarsi che solo il traffico che autorizziamo esplicitamente sia compito di un firewall.

#### Come Funziona

Il kernel Linux fornisce capacità per monitorare e controllare il traffico di rete. Queste capacità sono esposte all'utente finale tramite utilità firewall. Su Linux, il firewall più comune è [iptables](https://en.wikipedia.org/wiki/Iptables). Tuttavia, iptables è piuttosto complicato e confusionario (IMHO). È qui che entra in gioco UFW. Pensa a UFW come a un front-end per iptables. Semplifica il processo di gestione delle regole iptables che dicono al kernel Linux cosa fare con il traffico di rete.

**UFW** funziona permettendoti di configurare regole che:

- **consentono** o **negano**
- traffico **in entrata** o **in uscita**
- **verso** o **da** porte

Puoi creare regole specificando esplicitamente le porte o con configurazioni applicative che specificano le porte.

#### Obiettivi

- tutto il traffico di rete, in entrata e in uscita, bloccato tranne quelli che autorizziamo esplicitamente

#### Note

- Man mano che installi altri programmi, dovrai abilitare le porte/applicazioni necessarie.

#### Riferimenti

- https://launchpad.net/ufw

#### Passaggi

1. Installa ufw.

   Su sistemi basati su Debian:

   ``` bash
   sudo apt install ufw
   ```

1. Nega tutto il traffico in uscita:

   ``` bash
   sudo ufw default deny outgoing comment 'deny all outgoing traffic'
   ```

   > ```
   > Default outgoing policy changed to 'deny'
   > (be sure to update your rules accordingly)
   > ```

   Se non siete paranoici come me e non volete negare tutto il traffico in uscita, potete invece consentirlo:

   ``` bash
   sudo ufw default allow outgoing comment 'allow all outgoing traffic'
   ```

1. Nega tutto il traffico in entrata:

   ``` bash
   sudo ufw default deny incoming comment 'deny all incoming traffic'
   ```

1. Ovviamente vogliamo connessioni SSH in entrata. Usare limit invece di allow negherà automaticamente le connessioni da un indirizzo IP se tenta di avviare 6 o più connessioni entro una finestra di 30 secondi:

   ``` bash
   sudo ufw limit in ssh comment 'allow SSH connections in'
   ```

   > ```
   > Rules updated
   > Rules updated (v6)
   > ```

1. Consenti traffico aggiuntivo secondo le tue esigenze. Alcuni casi d'uso comuni:

   ``` bash
   # allow traffic out to port 53 -- DNS
   sudo ufw allow out 53 comment 'allow DNS calls out'
   
   # allow traffic out to port 123 -- NTP
   sudo ufw allow out 123 comment 'allow NTP out'

   # allow traffic out for HTTP, HTTPS, or FTP
   # apt might needs these depending on which sources you're using
   sudo ufw allow out http comment 'allow HTTP traffic out'
   sudo ufw allow out https comment 'allow HTTPS traffic out'
   sudo ufw allow out ftp comment 'allow FTP traffic out'

   # allow whois
   sudo ufw allow out whois comment 'allow whois'
   
   # allow mails for status notifications -- choose port according to your provider
   sudo ufw allow out 25 comment 'allow SMTP out'
   sudo ufw allow out 587 comment 'allow SMTP out'

   # allow traffic out to port 68 -- the DHCP client
   # you only need this if you're using DHCP
   sudo ufw allow out 67 comment 'allow the DHCP client to update'
   sudo ufw allow out 68 comment 'allow the DHCP client to update'
   ```
   
   **Nota**: Dovrai consentire HTTP/HTTPS per installare pacchetti e molte altre cose.

1. Avvia ufw:

   ``` bash
   sudo ufw enable
   ```

   > ```
   > Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
   > Firewall is active and enabled on system startup
   > ```

1. Se vuoi vedere lo stato:

   ``` bash
   sudo ufw status
   ```

   > ```
   > Status: active
   > 
   > To                         Action      From
   > --                         ------      ----
   > 22/tcp                     LIMIT       Anywhere                   # allow SSH connections in
   > 22/tcp (v6)                LIMIT       Anywhere (v6)              # allow SSH connections in
   > 
   > 53                         ALLOW OUT   Anywhere                   # allow DNS calls out
   > 123                        ALLOW OUT   Anywhere                   # allow NTP out
   > 80/tcp                     ALLOW OUT   Anywhere                   # allow HTTP traffic out
   > 443/tcp                    ALLOW OUT   Anywhere                   # allow HTTPS traffic out
   > 21/tcp                     ALLOW OUT   Anywhere                   # allow FTP traffic out
   > Mail submission            ALLOW OUT   Anywhere                   # allow mail out
   > 43/tcp                     ALLOW OUT   Anywhere                   # allow whois
   > 53 (v6)                    ALLOW OUT   Anywhere (v6)              # allow DNS calls out
   > 123 (v6)                   ALLOW OUT   Anywhere (v6)              # allow NTP out
   > 80/tcp (v6)                ALLOW OUT   Anywhere (v6)              # allow HTTP traffic out
   > 443/tcp (v6)               ALLOW OUT   Anywhere (v6)              # allow HTTPS traffic out
   > 21/tcp (v6)                ALLOW OUT   Anywhere (v6)              # allow FTP traffic out
   > Mail submission (v6)       ALLOW OUT   Anywhere (v6)              # allow mail out
   > 43/tcp (v6)                ALLOW OUT   Anywhere (v6)              # allow whois
   > ```

   oppure

   ``` bash
   sudo ufw status verbose
   ```

   > ```
   > Status: active
   > Logging: on (low)
   > Default: deny (incoming), deny (outgoing), disabled (routed)
   > New profiles: skip
   > 
   > To                         Action      From
   > --                         ------      ----
   > 22/tcp                     LIMIT IN    Anywhere                   # allow SSH connections in
   > 22/tcp (v6)                LIMIT IN    Anywhere (v6)              # allow SSH connections in
   > 
   > 53                         ALLOW OUT   Anywhere                   # allow DNS calls out
   > 123                        ALLOW OUT   Anywhere                   # allow NTP out
   > 80/tcp                     ALLOW OUT   Anywhere                   # allow HTTP traffic out
   > 443/tcp                    ALLOW OUT   Anywhere                   # allow HTTPS traffic out
   > 21/tcp                     ALLOW OUT   Anywhere                   # allow FTP traffic out
   > 587/tcp (Mail submission)  ALLOW OUT   Anywhere                   # allow mail out
   > 43/tcp                     ALLOW OUT   Anywhere                   # allow whois
   > 53 (v6)                    ALLOW OUT   Anywhere (v6)              # allow DNS calls out
   > 123 (v6)                   ALLOW OUT   Anywhere (v6)              # allow NTP out
   > 80/tcp (v6)                ALLOW OUT   Anywhere (v6)              # allow HTTP traffic out
   > 443/tcp (v6)               ALLOW OUT   Anywhere (v6)              # allow HTTPS traffic out
   > 21/tcp (v6)                ALLOW OUT   Anywhere (v6)              # allow FTP traffic out
   > 587/tcp (Mail submission (v6)) ALLOW OUT   Anywhere (v6)              # allow mail out
   > 43/tcp (v6)                ALLOW OUT   Anywhere (v6)              # allow whois
   > ```

7. Se hai bisogno di eliminare una regola
   
   ``` bash
   sudo ufw status numbered
   [...]
   sudo ufw delete 3 #line number of the rule you want to delete
   ```

#### Applicazioni Predefinite

ufw include alcune applicazioni predefinite. Puoi vederle con:``` bash
sudo ufw app list
```
> ```
> Available applications:
>   AIM
>   Bonjour
>   CIFS
>   DNS
>   Deluge
>   IMAP
>   IMAPS
>   IPP
>   KTorrent
>   Kerberos Admin
>   Kerberos Full
>   Kerberos KDC
>   Kerberos Password
>   LDAP
>   LDAPS
>   LPD
>   MSN
>   MSN SSL
>   Mail submission
>   NFS
>   OpenSSH
>   POP3
>   POP3S
>   PeopleNearby
>   SMTP
>   SSH
>   Socks
>   Telnet
>   Transmission
>   Transparent Proxy
>   VNC
>   WWW
>   WWW Cache
>   WWW Full
>   WWW Secure
>   XMPP
>   Yahoo
>   qBittorrent
>   svnserve
> ```

Per ottenere dettagli sull'app, come quali porte include, digita:``` bash
sudo ufw app info [app name]
```
> ``` bash
> sudo ufw app info DNS
> ```
> 
> ```
> Profile: DNS
> Title: Internet Domain Name Server
> Description: Internet Domain Name Server
> 
> Port:
>   53
> ```

#### Applicazione Personalizzata

Se non vuoi creare regole fornendo esplicitamente il numero o i numeri di porta, puoi creare le tue configurazioni di applicazione. Per farlo, crea un file in `/etc/ufw/applications.d`.

Ad esempio, ecco cosa useresti per [Plex](https://support.plex.tv/articles/201543147-what-network-ports-do-i-need-to-allow-through-my-firewall/):``` bash
cat /etc/ufw/applications.d/plexmediaserver
```
> ```
> [PlexMediaServer]
> title=Plex Media Server
> description=This opens up PlexMediaServer for http (32400), upnp, and autodiscovery.
> ports=32469/tcp|32413/udp|1900/udp|32400/tcp|32412/udp|32410/udp|32414/udp|32400/udp
> ```

Quindi puoi abilitarlo come qualsiasi altra app:```bash
sudo ufw allow plexmediaserver
```
([Table of Contents](#table-of-contents))

### Rilevamento e Prevenzione delle Intrusioni iptables con PSAD

#### Perché

Anche se hai un firewall per proteggere le tue porte, è possibile tentare di forzare l'ingresso in una qualsiasi delle porte sorvegliate. Vogliamo monitorare tutta l'attività di rete per rilevare potenziali tentativi di intrusione, come tentativi ripetuti di entrare, e bloccarli.

#### Come Funziona

Non posso spiegarlo meglio di quanto abbia fatto l'utente [FINESEC](https://serverfault.com/users/143961/finesec) da https://serverfault.com/ a: https://serverfault.com/a/447604/289829.

> Fail2BAN esamina i file di log di varie applicazioni come Apache, SSH o FTP e banna automaticamente gli IP che mostrano segni malintenzionati come tentativi di accesso automatizzati. PSAD, d'altra parte, esamina i messaggi di log di iptables e ip6tables (tipicamente /var/log/messages) per rilevare e opzionalmente bloccare scansioni e altri tipi di traffico sospetto come tentativi di DDoS o di fingerprinting del sistema operativo. È possibile utilizzare entrambi i programmi contemporaneamente perché operano a livelli diversi.

E, dato che stiamo già usando [UFW](#ufw-uncomplicated-firewall), seguiremo le fantastiche istruzioni di [netson](https://gist.github.com/netson) su https://gist.github.com/netson/c45b2dc4e835761fbccc per far funzionare PSAD con UFW.

#### Riferimenti

- http://www.cipherdyne.org/psad/
- http://www.cipherdyne.org/psad/docs/config.html
- https://www.thefanclub.co.za/how-to/how-install-psad-intrusion-detection-ubuntu-1204-lts-server
- https://serverfault.com/a/447604/289829
- https://serverfault.com/a/770424/289829
- https://gist.github.com/netson/c45b2dc4e835761fbccc
- Grazie a [moltenbit](https://github.com/moltenbit) per aver segnalato il problema ([#61](https://github.com/imthenachoman/How-To-Secure-A-Linux-Server/issues/61)) con `psadwatchd`.

#### Passaggi

1. Installa psad.

   Su sistemi basati su Debian:

   ``` bash
   sudo apt install psad
   ```

1. Esegui un backup del file di configurazione di psad `/etc/psad/psad.conf`:

   ``` bash
   sudo cp --archive /etc/psad/psad.conf /etc/psad/psad.conf-COPY-$(date +"%Y%m%d%H%M%S")
   ```

1. Rivedi e aggiorna le opzioni di configurazione in `/etc/psad/psad.conf`. Presta particolare attenzione a queste:

  |Impostazione|Impostato su
  |--|--|
  |[`EMAIL_ADDRESSES`](http://www.cipherdyne.org/psad/docs/config.html#EMAIL_ADDRESSES)|il tuo indirizzo(i) email|
  |`HOSTNAME`|il nome host del tuo server|
  |`EXPECT_TCP_OPTIONS`|`EXPECT_TCP_OPTIONS Y;`|
  |`ENABLE_PSADWATCHD`|`ENABLE_PSADWATCHD Y;`|
  |[`ENABLE_AUTO_IDS`](http://www.cipherdyne.org/psad/docs/config.html#ENABLE_AUTO_IDS)|`ENABLE_AUTO_IDS Y;`|
  |`ENABLE_AUTO_IDS_EMAILS`|`ENABLE_AUTO_IDS_EMAILS Y;`|

  Controlla il file di configurazione e la documentazione di psad su http://www.cipherdyne.org/psad/docs/config.html per maggiori dettagli.

1. <a name="psad_step4"></a>Ora dobbiamo apportare alcune modifiche a ufw in modo che funzioni con psad istruendo ufw a registrare tutto il traffico in modo che psad possa analizzarlo. Fallo modificando **due file** e aggiungendo queste righe **alla fine ma prima della riga COMMIT**.

   Esegui i backup:

   ``` bash
   sudo cp --archive /etc/ufw/before.rules /etc/ufw/before.rules-COPY-$(date +"%Y%m%d%H%M%S")
   sudo cp --archive /etc/ufw/before6.rules /etc/ufw/before6.rules-COPY-$(date +"%Y%m%d%H%M%S")
   ```

   Modifica i file:

   - `/etc/ufw/before.rules`
   - `/etc/ufw/before6.rules`

   E aggiungi questo **alla fine ma prima della riga COMMIT**:

   ```
   # log all traffic so psad can analyze
   -A INPUT -j LOG --log-tcp-options --log-prefix "[IPTABLES] "
   -A FORWARD -j LOG --log-tcp-options --log-prefix "[IPTABLES] "
   ```

   **Nota**: Stiamo aggiungendo un prefisso di log a tutti i log di iptables. Ne avremo bisogno per [separare i log di iptables in un file separato](#separate-iptables-log-file).

   Ad esempio:

   > ```
   > ...
   > 
   > # log all traffic so psad can analyze
   > -A INPUT -j LOG --log-tcp-options --log-prefix "[IPTABLES] "
   > -A FORWARD -j LOG --log-tcp-options --log-prefix "[IPTABLES] "
   > 
   > # don't delete the 'COMMIT' line or these rules won't be processed
   > COMMIT
   > ```

1. Ora dobbiamo ricaricare/riavviare ufw e psad affinché le modifiche abbiano effetto:

   ``` bash
   sudo ufw reload

   sudo psad -R
   sudo psad --sig-update
   sudo psad -H
   ```

1. Analizza le regole iptables per errori:

   ``` bash
   sudo psad --fw-analyze
   ```

   > ```
   > [+] Parsing INPUT chain rules.
   > [+] Parsing INPUT chain rules.
   > [+] Firewall config looks good.
   > [+] Completed check of firewall ruleset.
   > [+] Results in /var/log/psad/fw_check
   > [+] Exiting.
   > ```

   **Nota**: In caso di problemi riceverai un'email con l'errore.

1. Controlla lo stato di psad:

   ``` bash
   sudo psad --Status
   ```

   > ```
   > [-] psad: pid file /var/run/psad/psadwatchd.pid does not exist for psadwatchd on vm
   > [+] psad_fw_read (pid: 3444)  %CPU: 0.0  %MEM: 2.2
   >     Running since: Sat Feb 16 01:03:09 2019
   > 
   > [+] psad (pid: 3435)  %CPU: 0.2  %MEM: 2.7
   >     Running since: Sat Feb 16 01:03:09 2019
   >     Command line arguments: [none specified]
   >     Alert email address(es): root@localhost
   > 
   > [+] Version: psad v2.4.3
   > 
   > [+] Top 50 signature matches:
   >         [NONE]
   > 
   > [+] Top 25 attackers:
   >         [NONE]
   > 
   > [+] Top 20 scanned ports:
   >         [NONE]
   > 
   > [+] iptables log prefix counters:
   >         [NONE]
   > 
   >     Total protocol packet counters:
   > 
   > [+] IP Status Detail:
   >         [NONE]
   > 
   >     Total scan sources: 0
   >     Total scan destinations: 0
   > 
   > [+] These results are available in: /var/log/psad/status.out
   > ```

([Table of Contents](#table-of-contents))

### Rilevamento e Prevenzione delle Intrusioni delle Applicazioni con Fail2Ban

#### Perché

UFW dice al tuo server quali porte chiudere in modo che nessuno possa vederle e quali porte permettere agli utenti autorizzati. PSAD monitora l'attività di rete per rilevare e prevenire potenziali intrusioni - tentativi ripetuti di entrare. Ma che dire delle applicazioni/servizi in esecuzione sul tuo server, come SSH e Apache, per i quali il firewall è configurato per consentire l'accesso? Anche se l'accesso è consentito, non significa che tutti i tentativi di accesso siano validi e innocui. E se qualcuno tentasse di forzare l'ingresso in un'app web in esecuzione sul tuo server? È qui che entra in gioco Fail2ban.

#### Come Funziona

Fail2ban monitora i log delle tue applicazioni (come SSH e Apache) per rilevare e prevenire potenziali intrusioni. Monitorerà il traffico di rete/log e preverrà intrusioni bloccando attività sospette (ad esempio, più tentativi di connessione falliti consecutivi in un breve periodo di tempo).

#### Obiettivi

- monitoraggio della rete per attività sospette con divieto automatico degli IP offensivi.

#### Note

- Al momento, l'unica cosa in esecuzione su questo server è SSH, quindi vorremo che Fail2ban monitori SSH e banni se necessario.
- Man mano che installi altri programmi, dovrai creare/configurare le jail appropriate e abilitarle.

#### Riferimenti

- https://www.fail2ban.org/
- https://blog.vigilcode.com/2011/05/ufw-with-fail2ban-quick-secure-setup-part-ii/
- https://dodwell.us/security/ufw-fail2ban-portscan.html
- https://www.howtoforge.com/community/threads/fail2ban-and-ufw-on-debian.77261/

#### Passaggi

1. Installa fail2ban.

   Su sistemi basati su Debian:

   ``` bash
   sudo apt install fail2ban
   ```

1. Non vogliamo modificare `/etc/fail2ban/fail2ban.conf` o `/etc/fail2ban/jail.conf` perché un futuro aggiornamento potrebbe sovrascriverli, quindi creeremo invece una copia locale. Crea il file `/etc/fail2ban/jail.local` e aggiungi questo, dopo aver sostituito `[LAN SEGMENT]` e `[your email]` con i valori appropriati:

   ```
   [DEFAULT]
   # the IP address range we want to ignore
   ignoreip = 127.0.0.1/8 [LAN SEGMENT]

   # who to send e-mail to
   destemail = [your e-mail]

   # who is the email from
   sender = [your e-mail]

   # since we're using exim4 to send emails
   mta = mail

   # get email alerts
   action = %(action_mwl)s
   ```

   **Nota**: Il tuo server dovrà essere in grado di inviare email in modo che Fail2ban possa informarti di attività sospette e quando ha bannato un IP.

1. Dobbiamo creare una jail per SSH che dica a fail2ban di esaminare i log di SSH e usare ufw per bannare/sbannare gli IP secondo necessità. Crea una jail per SSH creando il file `/etc/fail2ban/jail.d/ssh.local` e aggiungendo questo:

   ```
   [sshd]
   enabled = true
   banaction = ufw
   port = ssh
   filter = sshd
   logpath = %(sshd_log)s
   maxretry = 5
   ```

   [For the lazy](#editing-configuration-files---for-the-lazy):

   ``` bash
   cat << EOF | sudo tee /etc/fail2ban/jail.d/ssh.local
   [sshd]
   enabled = true
   banaction = ufw
   port = ssh
   filter = sshd
   logpath = %(sshd_log)s
   maxretry = 5
   EOF
   ```

1. In quanto sopra diciamo a fail2ban di usare ufw come `banaction`. Fail2ban viene fornito con un file di configurazione delle azioni per ufw. Puoi vederlo in `/etc/fail2ban/action.d/ufw.conf`

1. Abilita fail2ban:

   ``` bash
   sudo fail2ban-client start
   sudo fail2ban-client reload
   sudo fail2ban-client add sshd # Questo potrebbe fallire su alcuni sistemi se la jail sshd è stata aggiunta per impostazione predefinita
   ```

1. Per controllare lo stato:

   ``` bash
   sudo fail2ban-client status
   ```

   > ```
   > Status
   > |- Number of jail:      1
   > `- Jail list:   sshd
   > ```

   ``` bash
   sudo fail2ban-client status sshd
   ```

   > ```
   > Status for the jail: sshd
   > |- Filter
   > |  |- Currently failed: 0
   > |  |- Total failed:     0
   > |  `- File list:        /var/log/auth.log
   > `- Actions
   >    |- Currently banned: 0
   >    |- Total banned:     0
   >    `- Banned IP list:
   > ```

#### Jail Personalizzate

Non ho ancora avuto bisogno di creare una jail personalizzata. Quando lo farò, e capirò come, aggiornerò questa guida. Oppure, se sai come fare, per favore aiuta a [contribuire](#contributing).

#### Sbannare un IP

Per sbannare un IP usa questo comando:``` bash
fail2ban-client set [jail] unbanip [IP]
```
`[jail]` è il nome della jail che contiene l'IP bannato e `[IP]` è l'indirizzo IP che si desidera sbloccare. Ad esempio, per sbloccare `192.168.1.100` da SSH si farebbe:``` bash
fail2ban-client set sshd unbanip 192.168.1.100
```
([Table of Contents](#table-of-contents))

### Rilevamento e Prevenzione delle Intrusioni Applicative con CrowdSec

#### Perché

UFW dice al tuo server quali porte chiudere in modo che nessuno possa vederle, e quali porte permettere agli utenti autorizzati. PSAD monitora l'attività di rete per rilevare e prevenire potenziali intrusioni: tentativi ripetuti di accesso.

CrowdSec è simile a Fail2Ban in quanto monitora i log delle tue applicazioni (come SSH e Apache) per rilevare e prevenire potenziali intrusioni. Tuttavia, CrowdSec è accoppiato a una comunità che condivide intelligence sulle minacce con CrowdSec per poi distribuire una Community Blocklist a tutti gli utenti.

#### Come Funziona

CrowdSec monitora i log delle tue applicazioni (come SSH e Apache) per rilevare e prevenire potenziali intrusioni. Monitorerà il traffico di rete/log e preverrà le intrusioni bloccando attività sospette (ad esempio, più tentativi di connessione falliti consecutivi in un breve lasso di tempo). Una volta rilevato un IP dannoso, verrà aggiunto alla tua lista di decisioni locale e le informazioni sulla minaccia vengono condivise con CrowdSec per aggiornare la Community Blocklist sugli indirizzi IP dannosi. Una volta che un indirizzo IP raggiunge una certa soglia di attività dannosa, verrà automaticamente propagato a tutti gli altri utenti di CrowdSec per essere bloccato in modo proattivo.

#### Obiettivi

- monitoraggio della rete per attività sospette con ban automatico degli IP offensivi

#### Note

- Al momento, l'unica cosa in esecuzione su questo server è SSH, quindi vogliamo che CrowdSec monitori SSH e banni se necessario.
- Mentre installi altri programmi, dovrai installare raccolte aggiuntive e configurare le acquisizioni appropriate.

#### Riferimenti

- https://www.crowdsec.net/
- [Leggi come CrowdSec cura la Community Blocklist](https://www.crowdsec.net/our-data)
- [Leggi quali intelligence sulle minacce viene condivisa con CrowdSec](https://docs.crowdsec.net/docs/next/central_api/intro#signal-meta-data)
- https://docs.crowdsec.net/

#### Passi

1. Installa CrowdSec Security Engine. (IDS)

   Su qualsiasi distribuzione Linux (inclusi sistemi basati su Debian)
   
   Installa il repository CrowdSec:
   ``` bash
   curl -s https://install.crowdsec.net | sudo sh
   ```

   Installa CrowdSec Security Engine:
   ``` bash
   sudo apt install crowdsec
   ```

> [!TIP]
> se `curl | sh` non fa per te, puoi trovare metodi di installazione aggiuntivi [qui](https://docs.crowdsec.net/u/getting_started/installation/linux).

Per impostazione predefinita, mentre CrowdSec installa il Security Engine rileverà automaticamente le tue applicazioni installate e installerà i parser e gli scenari appropriati per esse. Poiché sappiamo che la maggior parte dei server Linux esegue SSH già pronto, CrowdSec lo configurerà automaticamente per te.

2. Installa un Componente di Remediation. (IPS)

   CrowdSec di per sé è un motore di rilevamento, poiché nelle infrastrutture moderne potresti avere un firewall o WAF a monte, CrowdSec non bloccherà gli indirizzi IP da solo. Puoi installare un Componente di Remediation per bloccare gli indirizzi IP rilevati da CrowdSec.
   ```bash
   sudo apt install crowdsec-firewall-bouncer-iptables
   ```

> [!TIP]
> Se la tua installazione di UFW non utilizza `iptables` come backend, puoi in alternativa installare `crowdsec-firewall-bouncer-nftables`. Non c'è differenza nei binari installati, solo il file di configurazione è diverso.

Per impostazione predefinita, mentre il Componente di Remediation si installa, configurerà automaticamente le impostazioni necessarie per funzionare con il Security Engine se distribuito sullo stesso host (e se il security engine non è in un ambiente container).

3. Verifica che il rilevamento e la remediation funzionino come previsto:

   Il pacchetto CrowdSec include uno strumento CLI per verificare lo stato del Security Engine e del Componente di Remediation.

   ```bash
   sudo cscli metrics
   ```

   ```bash
   Acquisition Metrics:
   ╭────────────────────────┬────────────┬──────────────┬────────────────┬────────────────────────┬───────────────────╮
   │ Source                 │ Lines read │ Lines parsed │ Lines unparsed │ Lines poured to bucket │ Lines whitelisted │
   ├────────────────────────┼────────────┼──────────────┼────────────────┼────────────────────────┼───────────────────┤
   │ file:/var/log/auth.log │ 5          │ 4            │ 1              │ 10                     │ -                 │
   │ file:/var/log/syslog   │ 30         │ -            │ 30             │ -                      │ -                 │
   ╰────────────────────────┴────────────┴──────────────┴────────────────┴────────────────────────┴───────────────────╯

   Local API Decisions:
   ╭────────────────────────────────────────────┬────────┬────────┬───────╮
   │ Reason                                     │ Origin │ Action │ Count │
   ├────────────────────────────────────────────┼────────┼────────┼───────┤
   │ crowdsecurity/http-backdoors-attempts      │ CAPI   │ ban    │ 73    │
   │ crowdsecurity/http-bad-user-agent          │ CAPI   │ ban    │ 4836  │
   │ crowdsecurity/http-path-traversal-probing  │ CAPI   │ ban    │ 87    │
   │ crowdsecurity/http-probing                 │ CAPI   │ ban    │ 2010  │
   │ crowdsecurity/thinkphp-cve-2018-20062      │ CAPI   │ ban    │ 88    │
   │ crowdsecurity/CVE-2019-18935               │ CAPI   │ ban    │ 7     │
   │ crowdsecurity/CVE-2023-49103               │ CAPI   │ ban    │ 5     │
   │ crowdsecurity/http-admin-interface-probing │ CAPI   │ ban    │ 91    │
   │ ltsich/http-w00tw00t                       │ CAPI   │ ban    │ 3     │
   │ crowdsecurity/apache_log4j2_cve-2021-44228 │ CAPI   │ ban    │ 18    │
   │ crowdsecurity/nginx-req-limit-exceeded     │ CAPI   │ ban    │ 280   │
   │ crowdsecurity/ssh-slow-bf                  │ CAPI   │ ban    │ 3412  │
   │ crowdsecurity/spring4shell_cve-2022-22965  │ CAPI   │ ban    │ 1     │
   │ crowdsecurity/ssh-cve-2024-6387            │ CAPI   │ ban    │ 24    │
   │ crowdsecurity/CVE-2023-22515               │ CAPI   │ ban    │ 2     │
   │ crowdsecurity/http-cve-2021-41773          │ CAPI   │ ban    │ 172   │
   │ crowdsecurity/netgear_rce                  │ CAPI   │ ban    │ 14    │
   │ crowdsecurity/ssh-bf                       │ CAPI   │ ban    │ 2000  │
   │ crowdsecurity/CVE-2022-35914               │ CAPI   │ ban    │ 1     │
   │ crowdsecurity/http-cve-2021-42013          │ CAPI   │ ban    │ 2     │
   │ crowdsecurity/jira_cve-2021-26086          │ CAPI   │ ban    │ 9     │
   │ crowdsecurity/http-sensitive-files         │ CAPI   │ ban    │ 166   │
   │ crowdsecurity/http-wordpress-scan          │ CAPI   │ ban    │ 272   │
   │ crowdsecurity/CVE-2022-26134               │ CAPI   │ ban    │ 5     │
   │ crowdsecurity/http-generic-bf              │ CAPI   │ ban    │ 7     │
   │ crowdsecurity/http-open-proxy              │ CAPI   │ ban    │ 948   │
   │ crowdsecurity/http-crawl-non_statics       │ CAPI   │ ban    │ 339   │
   │ crowdsecurity/http-cve-probing             │ CAPI   │ ban    │ 5     │
   │ crowdsecurity/CVE-2017-9841                │ CAPI   │ ban    │ 117   │
   │ crowdsecurity/CVE-2022-37042               │ CAPI   │ ban    │ 1     │
   │ crowdsecurity/fortinet-cve-2018-13379      │ CAPI   │ ban    │ 5     │
   ╰────────────────────────────────────────────┴────────┴────────┴───────╯

   Local API Metrics:
   ╭──────────────────────┬────────┬──────╮
   │ Route                │ Method │ Hits │
   ├──────────────────────┼────────┼──────┤
   │ /v1/alerts           │ GET    │ 2    │
   │ /v1/decisions/stream │ GET    │ 5    │
   │ /v1/usage-metrics    │ POST   │ 2    │
   │ /v1/watchers/login   │ POST   │ 4    │
   ╰──────────────────────┴────────┴──────╯

   Local API Bouncers Metrics:
   ╭────────────────────────────────┬──────────────────────┬────────┬──────╮
   │ Bouncer                        │ Route                │ Method │ Hits │
   ├────────────────────────────────┼──────────────────────┼────────┼──────┤
   │ cs-firewall-bouncer-1729025592 │ /v1/decisions/stream │ GET    │ 5    │
   ╰────────────────────────────────┴──────────────────────┴────────┴──────╯

   Local API Machines Metrics:
   ╭──────────────────────────────────────────────────┬────────────┬────────┬──────╮
   │ Machine                                          │ Route      │ Method │ Hits │
   ├──────────────────────────────────────────────────┼────────────┼────────┼──────┤
   │ <your_machine_id_will_be_here>                   │ /v1/alerts │ GET    │ 2    │
   ╰──────────────────────────────────────────────────┴────────────┴────────┴──────╯

   Parser Metrics:
   ╭─────────────────────────────────┬──────┬────────┬──────────╮
   │ Parsers                         │ Hits │ Parsed │ Unparsed │
   ├─────────────────────────────────┼──────┼────────┼──────────┤
   │ child-crowdsecurity/sshd-logs   │ 41   │ 4      │ 37       │
   │ child-crowdsecurity/syslog-logs │ 35   │ 35     │ -        │
   │ crowdsecurity/dateparse-enrich  │ 4    │ 4      │ -        │
   │ crowdsecurity/sshd-logs         │ 5    │ 4      │ 1        │
   │ crowdsecurity/syslog-logs       │ 35   │ 35     │ -        │
   ╰─────────────────────────────────┴──────┴────────┴──────────╯

   Scenario Metrics:
   ╭─────────────────────────────────────┬───────────────┬───────────┬──────────────┬────────┬─────────╮
   │ Scenario                            │ Current Count │ Overflows │ Instantiated │ Poured │ Expired │
   ├─────────────────────────────────────┼───────────────┼───────────┼──────────────┼────────┼─────────┤
   │ crowdsecurity/ssh-bf                │ 1             │ -         │ 1            │ 4      │ -       │
   │ crowdsecurity/ssh-bf_user-enum      │ 1             │ -         │ 1            │ 1      │ -       │
   │ crowdsecurity/ssh-slow-bf           │ 1             │ -         │ 1            │ 4      │ -       │
   │ crowdsecurity/ssh-slow-bf_user-enum │ 1             │ -         │ 1            │ 1      │ -       │
   ╰─────────────────────────────────────┴───────────────┴───────────┴──────────────┴────────┴─────────╯
   ```

L'output sopra può essere scoraggiante, ma è un buon modo per verificare che il Security Engine stia leggendo i log e che il Componente di Remediation stia bloccando gli indirizzi IP. Quindi una rapida suddivisione di ogni sezione:

- **Acquisition Metrics**: Questa sezione mostra i log che il Security Engine sta leggendo e analizzando. Se vedi log nella colonna `Lines unparsed`, significa che il Security Engine non è in grado di analizzare i log. Ciò potrebbe essere dovuto a una configurazione errata o i log non sono nel formato previsto.
- **Local API Decisions**: Questa sezione mostra le decisioni che il Security Engine ha nel database. Se vedi log nella colonna `Count`, significa che il Security Engine ha rilevato attività dannosa e ha bloccato l'indirizzo IP.
   - Origin: Da dove proviene la decisione. In questo caso, è dall'API Centrale (CAPI).
- **Local API Metrics**: Questa sezione mostra il numero di chiamate all'API Locale. Questa è l'API che il Security Engine usa per comunicare con il Componente di Remediation.
- **Local API Bouncers Metrics**: Questa sezione mostra il numero di chiamate all'API Locale da parte del Componente di Remediation.
- **Local API Machines Metrics**: Questa sezione mostra il numero di chiamate all'API Locale da parte del Security Engine (se esegui più Security Engine in una configurazione centralizzata, puoi vedere più ID qui).
- **Parser Metrics**: Questa sezione mostra i parser utilizzati dal Security Engine. Se vedi log nella colonna `Unparsed`, significa che il Security Engine non è in grado di analizzare i log. Ciò potrebbe essere dovuto a una configurazione errata o i log non sono nel formato previsto.
- **Scenario Metrics**: Questa sezione mostra gli scenari utilizzati dal Security Engine. Se vedi log nella colonna `Current Count`, significa che il Security Engine ha rilevato attività dannosa e sta tracciando l'indirizzo IP.

#### Sbannare un IP

Per sbannare un IP usa questo comando:``` bash
cscli decisions delete --ip [IP]
```
`[IP]` è l'indirizzo IP che si desidera sbloccare. Ad esempio, per sbloccare `192.168.1.100` da SSH si farebbe:``` bash
cscli decisions delete --ip 192.168.1.100
```
## Il Controllo (Auditing)

### Monitoraggio dell'Integrità di File/Cartelle con AIDE (WIP)

#### Perché

WIP

#### Come Funziona

WIP

#### Obiettivi

WIP

#### Riferimenti

- https://aide.github.io/
- https://www.hiroom2.com/2017/06/09/debian-8-file-integrity-check-with-aide/
- https://blog.rapid7.com/2017/06/30/how-to-install-and-configure-aide-on-ubuntu-linux/
- https://www.stephenrlang.com/2016/03/using-aide-for-file-integrity-monitoring-fim-on-ubuntu/
- https://www.howtoforge.com/how-to-configure-the-aide-advanced-intrusion-detection-environment-file-integrity-scanner-for-your-website
- https://www.tecmint.com/check-integrity-of-file-and-directory-using-aide-in-linux/
- https://www.cyberciti.biz/faq/debian-ubuntu-linux-software-integrity-checking-with-aide/
- https://github.com/imthenachoman/How-To-Secure-A-Linux-Server/issues/83

#### Passi

1. Installa AIDE.

   Su sistemi basati su Debian:
   
   ``` bash
   sudo apt install aide aide-common
   ```
   
1. Fai una copia di backup del file predefinito di AIDE:

   ``` bash
   sudo cp -p /etc/default/aide /etc/default/aide-COPY-$(date +"%Y%m%d%H%M%S")
   ```

1. Esamina `/etc/default/aide` e imposta le impostazioni predefinite di AIDE secondo le tue esigenze. Se desideri che AIDE venga eseguito quotidianamente e ti invii un'email, assicurati di impostare `CRON_DAILY_RUN` su `yes`.

1. Fai una copia di backup dei file di configurazione di AIDE:

   ``` bash
   sudo cp -pr /etc/aide /etc/aide-COPY-$(date +"%Y%m%d%H%M%S")
   ```

1. Su sistemi basati su Debian:

   - I file di configurazione di AIDE si trovano in `/etc/aide/aide.conf.d/`.
   - Dovrai esaminare la documentazione di AIDE e i file di configurazione per impostarli secondo le tue esigenze.
   - Se desideri nuove impostazioni, ad esempio per monitorare una nuova cartella, dovrai aggiungerle a `/etc/aide/aide.conf` o `/etc/aide/aide.conf.d/`.
   - Fai un backup dei file di configurazione originali: `sudo cp -pr /etc/aide /etc/aide-COPY-$(date +"%Y%m%d%H%M%S")`.

1. Crea un nuovo database e installalo.
  
   Su sistemi basati su Debian:

   ``` bash
   sudo aideinit
   ```
   
   > ```
   > Running aide --init...
   > Start timestamp: 2019-04-01 21:23:37 -0400 (AIDE 0.16)
   > AIDE initialized database at /var/lib/aide/aide.db.new
   > Verbose level: 6
   > 
   > Number of entries:      25973
   > 
   > ---------------------------------------------------
   > The attributes of the (uncompressed) database(s):
   > ---------------------------------------------------
   > 
   > /var/lib/aide/aide.db.new
   >   RMD160   : moyQ1YskQQbidX+Lusv3g2wf1gQ=
   >   TIGER    : 7WoOgCrXzSpDrlO6I3PyXPj1gRiaMSeo
   >   SHA256   : gVx8Fp7r3800WF2aeXl+/KHCzfGsNi7O
   >              g16VTPpIfYQ=
   >   SHA512   : GYfa0DJwWgMLl4Goo5VFVOhu4BphXCo3
   >              rZnk49PYztwu50XjaAvsVuTjJY5uIYrG
   >              tV+jt3ELvwFzGefq4ZBNMg==
   >   CRC32    : /cusZw==
   >   HAVAL    : E/i5ceF3YTjwenBfyxHEsy9Kzu35VTf7
   >              CPGQSW4tl14=
   >   GOST     : n5Ityzxey9/1jIs7LMc08SULF1sLBFUc
   >              aMv7Oby604A=
   > 
   > 
   > End timestamp: 2019-04-01 21:24:45 -0400 (run time: 1m 8s)
   > ```

1. Verifica che tutto funzioni senza modifiche.

   Su sistemi basati su Debian:

   ``` bash
   sudo aide.wrapper --check
   ```
   
   > ```
   > Start timestamp: 2019-04-01 21:24:45 -0400 (AIDE 0.16)
   > AIDE found NO differences between database and filesystem. Looks okay!!
   > Verbose level: 6
   > 
   > Number of entries:      25973
   > 
   > ---------------------------------------------------
   > The attributes of the (uncompressed) database(s):
   > ---------------------------------------------------
   > 
   > /var/lib/aide/aide.db
   >   RMD160   : moyQ1YskQQbidX+Lusv3g2wf1gQ=
   >   TIGER    : 7WoOgCrXzSpDrlO6I3PyXPj1gRiaMSeo
   >   SHA256   : gVx8Fp7r3800WF2aeXl+/KHCzfGsNi7O
   >              g16VTPpIfYQ=
   >   SHA512   : GYfa0DJwWgMLl4Goo5VFVOhu4BphXCo3
   >              rZnk49PYztwu50XjaAvsVuTjJY5uIYrG
   >              tV+jt3ELvwFzGefq4ZBNMg==
   >   CRC32    : /cusZw==
   >   HAVAL    : E/i5ceF3YTjwenBfyxHEsy9Kzu35VTf7
   >              CPGQSW4tl14=
   >   GOST     : n5Ityzxey9/1jIs7LMc08SULF1sLBFUc
   >              aMv7Oby604A=
   > 
   > 
   > End timestamp: 2019-04-01 21:26:03 -0400 (run time: 1m 18s)
   > ```

1. Verifica che tutto funzioni dopo aver apportato alcune modifiche.

   Su sistemi basati su Debian:

   ``` bash
   sudo touch /etc/test.sh
   sudo touch /root/test.sh
   
   sudo aide.wrapper --check
   
   sudo rm /etc/test.sh
   sudo rm /root/test.sh
   
   sudo aideinit -y -f
   ```
   
   > ```
   > Start timestamp: 2019-04-01 21:37:37 -0400 (AIDE 0.16)
   > AIDE found differences between database and filesystem!!
   > Verbose level: 6
   > 
   > Summary:
   >   Total number of entries:      25972
   >   Added entries:                2
   >   Removed entries:              0
   >   Changed entries:              1
   > 
   > ---------------------------------------------------
   > Added entries:
   > ---------------------------------------------------
   > 
   > f++++++++++++++++: /etc/test.sh
   > f++++++++++++++++: /root/test.sh
   > 
   > ---------------------------------------------------
   > Changed entries:
   > ---------------------------------------------------
   > 
   > d =.... mc.. .. .: /root
   > 
   > ---------------------------------------------------
   > Detailed information about changes:
   > ---------------------------------------------------
   > 
   > Directory: /root
   >   Mtime    : 2019-04-01 21:35:07 -0400        | 2019-04-01 21:37:36 -0400
   >   Ctime    : 2019-04-01 21:35:07 -0400        | 2019-04-01 21:37:36 -0400
   > 
   > 
   > ---------------------------------------------------
   > The attributes of the (uncompressed) database(s):
   > ---------------------------------------------------
   > 
   > /var/lib/aide/aide.db
   >   RMD160   : qF9WmKaf2PptjKnhcr9z4ueCPTY=
   >   TIGER    : zMo7MvvYJcq1hzvTQLPMW7ALeFiyEqv+
   >   SHA256   : LSLLVjjV6r8vlSxlbAbbEsPcQUB48SgP
   >              pdVqEn6ZNbQ=
   >   SHA512   : Qc4U7+ZAWCcitapGhJ1IrXCLGCf1IKZl
   >              02KYL1gaZ0Fm4dc7xLqjiquWDMSEbwzW
   >              oz49NCquqGz5jpMIUy7UxA==
   >   CRC32    : z8ChEA==
   >   HAVAL    : YapzS+/cdDwLj3kHJEq8fufLp3DPKZDg
   >              U12KCSkrO7Y=
   >   GOST     : 74sLV4HkTig+GJhokvxZQm7CJD/NR0mG
   >              6jV7zdt5AXQ=
   > 
   > 
   > End timestamp: 2019-04-01 21:38:50 -0400 (run time: 1m 13s)
   > ```
   
1. Questo è tutto. Se hai impostato `CRON_DAILY_RUN` su `yes` in `/etc/default/aide`, allora cron eseguirà `/etc/cron.daily/aide` ogni giorno e ti invierà l'output via email.

#### Aggiornamento del Database

Ogni volta che apporti modifiche a file/cartelle monitorati da AIDE, dovrai aggiornare il database per catturare tali modifiche. Per farlo su sistemi basati su Debian:``` bash
sudo aideinit -y -f
```
([Table of Contents](#table-of-contents))

### Scansione Antivirus Con ClamAV (WIP)

#### Perché

WIP

#### Come Funziona

- ClamAV è uno scanner di virus
- ClamAV-Freshclam è un servizio che mantiene aggiornate le definizioni dei virus
- ClamAV-Daemon mantiene il processo `clamd` in esecuzione per velocizzare le scansioni

#### Obiettivi

WIP

#### Note

- Queste istruzioni **non** spiegano come abilitare il servizio demone di ClamAV per assicurarsi che `clamd` sia sempre in esecuzione. `clamd` è utile solo se stai gestendo un server di posta e non fornisce monitoraggio in tempo reale dei file. Invece, dovresti scansionare i file manualmente o in modo programmato.

#### Riferimenti

- https://www.clamav.net/documents/installation-on-debian-and-ubuntu-linux-distributions
- https://wiki.debian.org/ClamAV
- https://www.osradar.com/install-clamav-debian-9-ubuntu-18/
- https://www.lisenet.com/2014/automate-clamav-to-perform-daily-system-scan-and-send-email-notifications-on-linux/
- https://www.howtoforge.com/tutorial/configure-clamav-to-scan-and-notify-virus-and-malware/
- https://serverfault.com/questions/741299/is-there-a-way-to-keep-clamav-updated-on-debian-8
- https://askubuntu.com/questions/250290/how-do-i-scan-for-viruses-with-clamav
- https://ngothang.com/how-to-install-clamav-and-configure-daily-scanning-on-centos/

#### Passaggi

1. Installa ClamAV.

   Su sistemi basati su Debian:

   ``` bash
   sudo apt install clamav clamav-freshclam clamav-daemon
   ```

1. Crea una copia di backup del file di configurazione di `clamav-freshclam` `/etc/clamav/freshclam.conf`:

   ``` bash
   sudo cp --archive /etc/clamav/freshclam.conf /etc/clamav/freshclam.conf-COPY-$(date +"%Y%m%d%H%M%S")
   ```
   
1. Le impostazioni predefinite di `clamav-freshclam` sono probabilmente sufficienti, ma se desideri modificarle, puoi modificare il file `/etc/clamav/freshclam.conf` o utilizzare `dpkg-reconfigure`:

   ``` bash
   sudo dpkg-reconfigure clamav-freshclam
   ```
   
   **Nota**: Le impostazioni predefinite aggiornano le definizioni 24 volte al giorno. Per modificare l'intervallo, controlla l'impostazione `Checks` in `/etc/clamav/freshclam.conf` o usa `dpkg-reconfigure`.

1. Avvia il servizio `clamav-freshclam`:

   ``` bash
   sudo service clamav-freshclam start
   ```
   
1. Puoi verificare che `clamav-freshclam` sia in esecuzione:

   ``` bash
   sudo service clamav-freshclam status
   ```
   
   > ```
   > ● clamav-freshclam.service - ClamAV virus database updater
   >    Loaded: loaded (/lib/systemd/system/clamav-freshclam.service; enabled; vendor preset: enabled)   Active: active (running) since Sat 2019-03-16 22:57:07 EDT; 2min 13s ago
   >      Docs: man:freshclam(1)
   >            man:freshclam.conf(5)
   >            https://www.clamav.net/documents
   >  Main PID: 1288 (freshclam)
   >    CGroup: /system.slice/clamav-freshclam.service
   >            └─1288 /usr/bin/freshclam -d --foreground=true
   > 
   > Mar 16 22:57:08 host freshclam[1288]: Sat Mar 16 22:57:08 2019 -> ^Local version: 0.100.2 Recommended version: 0.101.1
   > Mar 16 22:57:08 host freshclam[1288]: Sat Mar 16 22:57:08 2019 -> DON'T PANIC! Read https://www.clamav.net/documents/upgrading-clamav
   > Mar 16 22:57:15 host freshclam[1288]: Sat Mar 16 22:57:15 2019 -> Downloading main.cvd [100%]
   > Mar 16 22:57:38 host freshclam[1288]: Sat Mar 16 22:57:38 2019 -> main.cvd updated (version: 58, sigs: 4566249, f-level: 60, builder: sigmgr)
   > Mar 16 22:57:40 host freshclam[1288]: Sat Mar 16 22:57:40 2019 -> Downloading daily.cvd [100%]
   > Mar 16 22:58:13 host freshclam[1288]: Sat Mar 16 22:58:13 2019 -> daily.cvd updated (version: 25390, sigs: 1520006, f-level: 63, builder: raynman)
   > Mar 16 22:58:14 host freshclam[1288]: Sat Mar 16 22:58:14 2019 -> Downloading bytecode.cvd [100%]
   > Mar 16 22:58:16 host freshclam[1288]: Sat Mar 16 22:58:16 2019 -> bytecode.cvd updated (version: 328, sigs: 94, f-level: 63, builder: neo)
   > Mar 16 22:58:24 host freshclam[1288]: Sat Mar 16 22:58:24 2019 -> Database updated (6086349 signatures) from db.local.clamav.net (IP: 104.16.219.84)
   > Mar 16 22:58:24 host freshclam[1288]: Sat Mar 16 22:58:24 2019 -> ^Clamd was NOT notified: Can't connect to clamd through /var/run/clamav/clamd.ctl: No such file or directory
   > ```
   
   **Nota**: Non preoccuparti per quella riga `Local version`. Controlla https://serverfault.com/questions/741299/is-there-a-way-to-keep-clamav-updated-on-debian-8 per maggiori dettagli.

1. Crea una copia di backup del file di configurazione di `clamav-daemon` `/etc/clamav/clamd.conf`:

   ``` bash
   sudo cp --archive /etc/clamav/clamd.conf /etc/clamav/clamd.conf-COPY-$(date +"%Y%m%d%H%M%S")
   ```
   
1. Puoi modificare le impostazioni di `clamav-daemon` modificando il file `/etc/clamav/clamd.conf` o utilizzando `dpkg-reconfigure`:

   ``` bash
   sudo dpkg-reconfigure clamav-daemon
   ```

#### Scansione di File/Cartelle

- Per scansionare file/cartelle usa il programma `clamscan`.
- `clamscan` viene eseguito con l'utente con cui viene lanciato, quindi necessita dei permessi di lettura per i file/cartelle che sta scansionando.
- Usare `clamscan` come `root` è pericoloso perché se un file è effettivamente un virus, c'è il rischio che possa sfruttare i privilegi di root.
- Per scansionare un file: `clamscan /path/to/file`.
- Per scansionare una directory: `clamscan -r /path/to/folder`.
- Puoi usare l'opzione `-i` per stampare solo i file infetti.
- Controlla le pagine man di `clamscan` per altre opzioni.

([Table of Contents](#table-of-contents))

### Rilevamento Rootkit Con Rkhunter (WIP)

#### Perché

WIP

#### Come Funziona

WIP

#### Obiettivi

WIP

#### Riferimenti

- http://rkhunter.sourceforge.net/
- https://www.cyberciti.biz/faq/howto-check-linux-rootkist-with-detectors-software/
- https://www.tecmint.com/install-rootkit-hunter-scan-for-rootkits-backdoors-in-linux/

#### Passaggi

1. Installa Rkhunter.

   Su sistemi basati su Debian:
   
   ``` bash
   sudo apt install rkhunter
   ```

1. Crea un backup del file dei valori predefiniti di rkhunter:

   ``` bash
   sudo cp -p /etc/default/rkhunter /etc/default/rkhunter-COPY-$(date +"%Y%m%d%H%M%S")
   ```

1. Il file di configurazione di rkhunter è `/etc/rkhunter.conf`. Invece di apportare modifiche ad esso, crea e usa il file `/etc/rkhunter.conf.local`:

   ``` bash
   sudo cp -p /etc/rkhunter.conf /etc/rkhunter.conf.local
   ```
   
1. Esamina il file di configurazione `/etc/rkhunter.conf.local` e impostalo secondo le tue esigenze. Le mie raccomandazioni:

   |Impostazione|Nota|
   |--|--|
   |`UPDATE_MIRRORS=1`||
   |`MIRRORS_MODE=0`||
   |`MAIL-ON-WARNING=root`||
   |`COPY_LOG_ON_ERROR=1`|per salvare una copia del log in caso di errore|
   |`PKGMGR=...`|imposta al valore appropriato secondo la documentazione|
   |`PHALANX2_DIRTEST=1`|leggi la documentazione per capire il perché|
   |`WEB_CMD=""`|questo serve per risolvere un problema con il pacchetto Debian che disabilita la capacità di rkhunter di auto-aggiornarsi.|
   |`USE_LOCKING=1`|per prevenire problemi con l'esecuzione multipla di rkhunter|
   |`SHOW_SUMMARY_WARNINGS_NUMBER=1`|per vedere il numero effettivo di avvisi trovati|

1. Vuoi che rkhunter venga eseguito ogni giorno e ti invii per e-mail il risultato. Puoi scrivere il tuo script o controllare https://www.tecmint.com/install-rootkit-hunter-scan-for-rootkits-backdoors-in-linux/ per un esempio di script cron da usare.
  
   Su sistemi basati su Debian, rkhunter viene fornito con script cron. Per abilitarli controlla `/etc/default/rkhunter` o usa `dpkg-reconfigure` e rispondi `Sì` a tutte le domande:
   
   ``` bash
   sudo dpkg-reconfigure rkhunter
   ```

1. Dopo aver terminato tutte le modifiche, assicurati che tutte le impostazioni siano valide:

   ``` bash
   sudo rkhunter -C
   ```

1. Aggiorna rkhunter e il suo database:

   ``` bash
   sudo rkhunter --versioncheck
   sudo rkhunter --update
   sudo rkhunter --propupd
   ```

1. Se vuoi eseguire una scansione manuale e vedere l'output:

   ``` bash
   sudo rkhunter --check
   ```

([Table of Contents](#table-of-contents))

### Rilevamento Rootkit Con chkrootkit (WIP)

#### Perché

WIP

#### Come Funziona

WIP

#### Obiettivi

WIP

#### Riferimenti

- http://www.chkrootkit.org/

AllowGroups	nome di un gruppo UNIX locale	`AllowGroups sshusers`	gruppo a cui consentire l'accesso SSH
ClientAliveCountMax	numero	`ClientAliveCountMax 3`	numero massimo di messaggi di keepalive del client inviati senza risposta
ClientAliveInterval	numero di secondi	`ClientAliveInterval 15`	timeout in secondi prima di una richiesta di risposta
ListenAddress	elenco separato da spazi di indirizzi locali	`ListenAddress 0.0.0.0` `ListenAddress 192.168.1.100`	indirizzi locali su cui `sshd` deve ascoltare	Vedi Issue #1 per dettagli importanti.
LoginGraceTime	numero di secondi	`LoginGraceTime 30`	tempo in secondi prima del timeout del login
MaxAuthTries	numero	`MaxAuthTries 2`	numero massimo di tentativi di accesso consentiti
MaxSessions	numero	`MaxSessions 2`	numero massimo di sessioni aperte
MaxStartups	numero	`MaxStartups 2`	numero massimo di sessioni di login
PasswordAuthentication	`yes` o `no`	`PasswordAuthentication no`	se l'accesso con password è consentito
Port	qualsiasi numero di porta aperta/disponibile	`Port 22`	porta su cui `sshd` deve ascoltare

How-To-Secure-A-Linux-Server

Più Popolari

Come Proteggere un Server Linux

Indice

Introduzione

Obiettivo della Guida

Perché Proteggere il Tuo Server

Perché Un'Altra Guida

Altre Guide

Da Fare / Da Aggiungere

Panoramica della Guida

Informazioni Su Questa Guida

Il Mio Caso d'Uso

Modificare i File di Configurazione - Per i Pigri

Contribuire

Prima di Iniziare

Identifica i Tuoi Principi

Scegliere una Distribuzione Linux

Installare Linux

Requisiti Pre/Post Installazione

Altre Note Importanti

Utilizzare Playbook Ansible per Proteggere il Tuo Server Linux

Il Server SSH

Nota Importante Prima di Apportare Modifiche SSH

Chiavi Pubbliche/Private SSH

Perché

Come Funziona

Obiettivi

Note

Riferimenti

Passi

Creare un Gruppo SSH per AllowGroups

Perché

Come Funziona

Obiettivi

Note

Riferimenti

Passi

Secure /etc/ssh/sshd_config

Perché

Come Funziona

Obiettivi

Note

Riferimenti

Passi

Rimuovere le Chiavi Diffie-Hellman Corte

Perché

Obiettivi

Riferimenti

Passi

2FA/MFA per SSH

Perché

Perché No

Come Funziona

Obiettivi

Note

Riferimenti

Passi

Le basi

Limitare chi può usare sudo

Perché

Obiettivi

Note

Passi

Limitare chi può usare su

Perché

Obiettivi

Riferimenti

Passi

Eseguire applicazioni in una sandbox con FireJail

Perché

Obiettivi

Riferimenti

Passi

Client NTP

Perché

Come funziona

Obiettivi

Riferimenti

Passi

Secure `/etc/ssh/sshd_config`

* EDIT THIS SCRIPT TO YOUR PROPOSES *#