> Nota: tutte le configurazioni successive, e i relativi comandi, fanno riferimento a un OS Debian 12
## ssh
ssh (Secure Shell) è un protocollo crittografico progettato per consentire la comunicazione sicura su una rete non sicura. Viene comunemente utilizzato per accedere in modo remoto a sistemi informatici e per eseguire comandi da remoto in modo sicuro.
### Generazione delle chiavi
Sulla propria macchina, generare le chiavi coi seguenti comandi:
```bash
ssh-keygen -t ed25519 -f ~/.ssh/keyname
cat ~/.ssh/keyname.pub
```
Quindi collegarsi al server remoto e caricare la chiave pubblica nel file `~/.ssh/authorized_keys`, situato nella home dell'utente autorizzato a connettersi, nel esempio *user1*.
#### Configurazione ssh
Sulla macchina remota, configurare ssh nel modo seguente
```bash
> grep -v ^# /etc/ssh/sshd_config
Include /etc/ssh/sshd_config.d/*.conf
Port 1329
Protocol 2
LogLevel INFO
MaxAuthTries 3
PubkeyAuthentication yes
PasswordAuthentication no
PermitEmptyPasswords no
KbdInteractiveAuthentication no
UsePAM yes
PrintMotd no
Banner none
PermitRootLogin no
AllowUsers user1
MACs hmac-sha1,hmac-sha2-256,hmac-sha2-512
```
In particolare:
- **Port 1329**: Specifica la porta su cui il server SSH ascolta le connessioni in arrivo. In questo caso, il server SSH ascolterà sulla porta 1329 anziché sulla porta predefinita 22.
- **Protocol 2**: Specifica che il server SSH dovrebbe utilizzare solo la versione 2 del protocollo SSH. La versione 1 del protocollo è considerata meno sicura e non dovrebbe essere utilizzata.
- **LogLevel INFO**: Imposta il livello di dettaglio dei log a "INFO", il che significa che verranno registrate informazioni di livello informativo nei log di sistema.
- **MaxAuthTries 3**: Limita il numero di tentativi di autenticazione consentiti prima che una connessione venga interrotta.
- **PubkeyAuthentication yes**: Abilita l'autenticazione tramite chiave pubblica. Gli utenti possono autenticarsi utilizzando una coppia di chiavi pubbliche e private anziché una password.
- **PasswordAuthentication no**: Disabilita l'autenticazione tramite password. Gli utenti non possono accedere al server SSH inserendo una password.
- **PermitEmptyPasswords no**: Impedisce agli utenti di utilizzare password vuote per l'autenticazione.
- **KbdInteractiveAuthentication no**: Disabilita l'autenticazione interattiva basata sulla tastiera.
- **UsePAM yes**: Abilita l'utilizzo del modulo di autenticazione PAM (Pluggable Authentication Modules) per gestire l'autenticazione degli utenti.
- **PrintMotd no**: Impedisce la visualizzazione del "Message of the Day" all'accesso.
- **Banner none**: Non visualizza alcun banner all'accesso.
- **PermitRootLogin no**: Impedisce il login diretto come utente root.
- **AllowUsers user1**: Specifica gli utenti che sono autorizzati a connettersi al server SSH. In questo caso, solo l'utente "user1" è autorizzato.
Sulla propria macchina, creare il seguente file di configurazione:
```bash
> cat .ssh/config
Host *
ForwardAgent yes
ControlMaster yes
Compression yes
Host name
hostname ip_server
user user1
IdentityFile ~/.ssh/keyname
TCPKeepAlive yes
port 1329
```
Testare il collegamento.
> Nota: per eliminare la schermata di benvenuto, dare il seguente comando, una volta che il collegamento sia avvenuto correttamente: `echo "" > /etc/motd`
## fail2ban
Fail2ban è un software open-source che monitora i log del sistema in tempo reale e, in base a determinati criteri di configurazione, blocca automaticamente gli indirizzi IP sospetti che tentano di accedere ripetutamente al server. Questo strumento aiuta a migliorare la sicurezza del server riducendo il rischio di accessi non autorizzati.
Sulla macchina remota, installare fail2ban:
```bash
apt install fail2ban
```
Verificare che nel file `/etc/fail2ban/jail.con` siano presenti le seguenti impostazioni:
```bash
# "bantime" is the number of seconds that a host is banned.
bantime = 120m
# A host is banned if it has generated "maxretry" during the last "findtime"
# seconds.
findtime = 5m
# "maxretry" is the number of failures before a host get banned.
maxretry = 5
```
### Configurazione fail2ban
Creare il seguente file:
```bash
> cat /etc/fail2ban/jail.d/defaults-debian.conf
[sshd]
enabled = true
port = 1329
filter = sshd
maxretry = 3
findtime = 5m
bantime = 120m
```
Questo file configura fail2ban per monitorare e proteggere il servizio ssh sulla porta 1329, consentendo un massimo di 3 tentativi di accesso non validi entro un periodo di 5 minuti prima di bloccare l'indirizzo IP sospetto per 120 minuti.
Quindi abilitare e avviare il servizio:
```bash
> systemctl enable --now fail2ban && systemctl status fail2ban.service
```
Infine, verificare che tutte le impostazioni siano corrette:
```bash
> fail2ban-client status
Status
|- Number of jail: 1
`- Jail list: sshd
> fail2ban-client status sshd
Status for the jail: sshd
|- Filter
| |- Currently failed: 0
| |- Total failed: 0
| `- File list:
`- Actions
|- Currently banned: 0
|- Total banned: 0
`- Banned IP list:
```
## ufw
ufw (Uncomplicated Firewall) è un frontend per iptables che semplifica la gestione del firewall su sistemi Linux.
Il precedente comando imposta le politiche predefinite del firewall per il traffico in uscita e in entrata.
Questo comando configura UFW per consentire tutto il traffico in uscita e bloccare tutto il traffico in entrata di default, fornendo una base di sicurezza per il sistema.
Infine, consentire solo il traffico in ingresso dalle porte tcp 80 e 443 e sulla porta 1329 per ssh:
Un reverse proxy è un server che si trova tra i client e uno o più server di backend. Quando un client invia una richiesta al reverse proxy, questo instrada la richiesta al server di backend appropriato e restituisce la risposta al client.
Caddy è un server web open-source che funge da reverse proxy e offre funzionalità avanzate come il rinnovo automatico dei certificati SSL, configurazione semplificata tramite file di configurazione Caddyfile e supporto per HTTP/2.
### Installazione di caddy
```bash
apt install caddy
```
### Configurazione
Modificare il file seguente, in base ai servizi che si installeranno:
Queste configurazioni consentono a Caddy di agire come reverse proxy per instradare il traffico verso i servizi specificati in base al sottodominio richiesto.
Abilitare e avviare il servizio:
```bash
> systemctl enable --now caddy.service
```
Verificare il log in tempo reale del servizio:
```bash
> journalctl -f -u caddy.service
```
Quando Caddy riceve una richiesta su una determinata porta (ad esempio la porta 443 per HTTPS), gestirà internamente il routing del traffico verso i servizi backend specificati nel file di configurazione, senza dover aprire le porte sul firewall del sistema. Questo è uno dei vantaggi dell'utilizzo di un reverse proxy per gestire il traffico web in modo sicuro ed efficiente.
> Nota: non tutte le precedenti operazioni vengono svolte in ordine, rispettivamente a come scritte. Bisogna inoltre possedere un dominio valido e configurare i record dns nel modo adeguato
## Docker
Docker è una piattaforma open-source che consente di creare, distribuire e gestire applicazioni in container. I container Docker consentono di isolare le applicazioni e le loro dipendenze in ambienti autonomi e possono essere eseguiti in modo consistente su qualsiasi sistema che abbia Docker installato.
Docker Compose è uno strumento aggiuntivo che consente di definire e gestire applicazioni multi-container utilizzando un singolo file di configurazione, chiamato appunto `docker-compose.yml`. Docker Compose semplifica la gestione di applicazioni distribuite composte da più servizi, consentendo di avviare, arrestare e gestire l'intera applicazione con un singolo comando.
Il file `.env` è un file di configurazione che contiene variabili d'ambiente utilizzate per configurare le applicazioni Docker. Queste variabili possono includere impostazioni come le porte di rete, le password, le chiavi di accesso e altre configurazioni specifiche dell'ambiente.
Per installare docker e docker compose, seguire la guida ufficiale: [Install Docker Engine on Debian](https://docs.docker.com/engine/install/debian/)
### Docker compose
Questi i comandi principali, da dare nella cartella dove si trova il file `docker-compose.yml`:
-`docker-compose pull`: Scarica le immagini dei servizi specificati nel file `docker-compose.yml`.
-`docker-compose up -d`: Avvia i container dei servizi definiti nel file `docker-compose.yml`.
-`docker-compose down`: Questo comando fermerà e rimuoverà i container, le reti e i volumi creati dall'esecuzione di `docker-compose up`.
> Nota: tutte le variabili nei file docker-compose, sono gestite nei rispettivi file .env
#### gitea
```bash
> cat gitea/docker-compose.yml
services:
gitea:
image: gitea/gitea:latest
env_file: .env
container_name: gitea
restart: unless-stopped
environment:
- USER_UID=102
- USER_GID=109
networks:
- gitea
volumes:
- ./gitea:/data
- /home/git/.ssh/:/data/git/.ssh
- /etc/timezone:/etc/timezone:ro
- /etc/localtime:/etc/localtime:ro
ports:
- "3006:3000"
- "2222:22"
networks:
gitea:
external: false
```
##### ssh passthrough
1) Creare sulla macchina remota l'utente di sistema git:
2) Verificare GID e UID dell'utente, che andranno inseriti nel file docker-compose.yml:
```bash
> getent passwd git
git:x:102:109:Git Version Control,,,:/home/git:/home/git/docker-shell
```
3) Nella home, creare il seguente script:
```bash
> ll /home/git/
Permissions Size User Date Modified Name
.rwxr--r-- 106 root 26 apr 18:32 docker-shell
> cat /home/git/docker-shell
#!/bin/sh
/usr/bin/docker exec -i -u git --env SSH_ORIGINAL_COMMAND="$SSH_ORIGINAL_COMMAND" gitea sh "$@"
```
4) Creare una chiave ssh per l'utente git e aggiungere la chiave pubblica al file `~/git/.ssh/authorized_keys`, che sara' montato direttamente nel container.
```bash
sudo -u git ssh-keygen -t ed25519 -C git
sudo -u git cat /home/git/.ssh/git.pub | sudo -u git tee -a /home/git/.ssh/authorized_keys
> La chiave pubblica dell'utente git deve essere aggiunta "così com'è", mentre tutte le altre chiavi pubbliche aggiunte tramite l'interfaccia web di Gitea saranno precedute da command="/usr [...].
5) Aggiungere l seguente blocco a `/etc/ssh/sshd_config` sull'host remoto:
