SSH e Chiavi: Guida Completa alla Sicurezza

Introduzione a SSH

SSH (Secure Shell) è il protocollo standard per connettersi in modo sicuro a server remoti. Che tu stia gestendo server, deployando applicazioni, accedendo a repository Git o amministrando infrastrutture cloud, capire SSH e le chiavi crittografiche è fondamentale per ogni sviluppatore e sysadmin moderno.

Come Funziona SSH

Crittografia Asimmetrica

SSH utilizza la crittografia a chiave pubblica (asimmetrica) per l'autenticazione. Questo sistema si basa su una coppia di chiavi matematicamente correlate:

• Chiave privata: Resta sul tuo computer, MAI condividerla con nessuno
• Chiave pubblica: Va sui server a cui vuoi accedere, può essere condivisa liberamente

Il Processo di Autenticazione

# Flusso di autenticazione SSH
1. Client inizia connessione TCP al server (porta 22)
2. Server e client negoziano algoritmi di cifratura
3. Server invia la sua chiave pubblica per verificare identità
4. Client verifica fingerprint del server (prima connessione)
5. Se autenticazione a chiave:
   - Server genera una "sfida" random
   - Client firma la sfida con la sua chiave privata
   - Server verifica la firma con la chiave pubblica del client
6. Canale sicuro stabilito, sessione inizia

Generare Chiavi SSH

Algoritmi Disponibili

Algoritmo	Sicurezza	Velocità	Compatibilità	Raccomandato
Ed25519	Molto Alta	Veloce	Moderna (2014+)	Preferito
RSA 4096	Alta	Lenta	Universale	Fallback
ECDSA	Alta	Veloce	Buona	Accettabile
DSA	Obsoleto	Lenta	Legacy	Mai usare

Generare Chiave Ed25519

# Comando raccomandato (moderno, sicuro, veloce)
ssh-keygen -t ed25519 -C "tuo@email.com"

# Output interattivo:
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

# File creati:
~/.ssh/id_ed25519      # Chiave PRIVATA (proteggila!)
~/.ssh/id_ed25519.pub  # Chiave pubblica

# Verifica chiave generata
ssh-keygen -l -f ~/.ssh/id_ed25519.pub
# 256 SHA256:ABC123... user@email (ED25519)

Generare Chiave RSA

# Per compatibilità con sistemi legacy
ssh-keygen -t rsa -b 4096 -C "tuo@email.com"

# -b 4096: lunghezza chiave (minimo 2048, 4096 raccomandato)
# -C: commento (solitamente email)

# Opzioni aggiuntive utili:
-f ~/.ssh/id_rsa_custom  # Nome file personalizzato
-N "passphrase"          # Passphrase non interattiva

Passphrase: Sì o No?

• Con passphrase: Più sicuro, richiede password ad ogni uso
• Senza passphrase: Meno sicuro, conveniente per automazione
• Raccomandazione: Usa passphrase + SSH agent per bilanciare sicurezza e comodità

Configurare SSH

File di Configurazione Client

# ~/.ssh/config
# Configura alias e opzioni per connessioni

# Server di produzione
Host produzione
    HostName 192.168.1.100
    User deploy
    IdentityFile ~/.ssh/id_ed25519_prod
    Port 22
    ForwardAgent no

# Server di staging
Host staging
    HostName staging.example.com
    User admin
    IdentityFile ~/.ssh/id_ed25519_staging
    ProxyJump bastion

# Bastion/Jump host
Host bastion
    HostName bastion.example.com
    User admin
    IdentityFile ~/.ssh/id_ed25519_bastion

# GitHub
Host github
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_github
    AddKeysToAgent yes

# GitLab
Host gitlab
    HostName gitlab.com
    User git
    IdentityFile ~/.ssh/id_ed25519_gitlab

# Opzioni globali
Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
    AddKeysToAgent yes
    IdentitiesOnly yes

Copiare la Chiave sul Server

# Metodo automatico (raccomandato)
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# Metodo manuale (se ssh-copy-id non disponibile)
cat ~/.ssh/id_ed25519.pub | ssh user@server \
  "mkdir -p ~/.ssh && chmod 700 ~/.ssh && \
   cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

# Verifica connessione
ssh user@server

Permessi Corretti

# Permessi CRITICI per sicurezza
chmod 700 ~/.ssh               # Directory SSH
chmod 600 ~/.ssh/id_ed25519    # Chiave privata
chmod 644 ~/.ssh/id_ed25519.pub # Chiave pubblica
chmod 600 ~/.ssh/authorized_keys # Sul server
chmod 600 ~/.ssh/config        # File config

SSH per GitHub/GitLab

Configurazione GitHub

# 1. Genera chiave dedicata
ssh-keygen -t ed25519 -C "tuo@email.com" -f ~/.ssh/id_ed25519_github

# 2. Aggiungi all'agent
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519_github

# 3. Copia la chiave pubblica
cat ~/.ssh/id_ed25519_github.pub
# Copia l'output

# 4. Vai su GitHub → Settings → SSH Keys → New SSH Key
# Incolla la chiave pubblica

# 5. Testa la connessione
ssh -T git@github.com
# Hi username! You've successfully authenticated

# 6. Clona con SSH
git clone git@github.com:username/repo.git

Account Multipli

# ~/.ssh/config per gestire più account GitHub
Host github-personal
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_personal

Host github-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_ed25519_work

# Uso:
git clone git@github-personal:myuser/personal-repo.git
git clone git@github-work:company/work-repo.git

# Configura anche git per directory
# ~/work/.gitconfig
[user]
    email = work@company.com

# ~/personal/.gitconfig
[user]
    email = personal@email.com

SSH Agent

Cos'è e Perché Usarlo

L'SSH agent memorizza le chiavi decriptate in memoria, così non devi inserire la passphrase ogni volta. È essenziale per workflow produttivi.

# Avvia l'agent
eval "$(ssh-agent -s)"
# Agent pid 12345

# Aggiungi chiave (chiede passphrase una sola volta)
ssh-add ~/.ssh/id_ed25519
# Identity added: /home/user/.ssh/id_ed25519

# Lista chiavi caricate
ssh-add -l
# 256 SHA256:ABC123... user@email (ED25519)

# Rimuovi una chiave
ssh-add -d ~/.ssh/id_ed25519

# Rimuovi tutte le chiavi
ssh-add -D

Configurazione Permanente

# ~/.bashrc o ~/.zshrc
if [ -z "$SSH_AUTH_SOCK" ]; then
    eval "$(ssh-agent -s)" > /dev/null
    ssh-add ~/.ssh/id_ed25519 2>/dev/null
fi

# macOS: usa Keychain (persiste dopo reboot)
# ~/.ssh/config
Host *
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/id_ed25519

Sicurezza Avanzata

Hardening Server SSH

# /etc/ssh/sshd_config sul SERVER

# Disabilita login con password
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no

# Disabilita root login
PermitRootLogin no

# Limita utenti autorizzati
AllowUsers deploy admin

# Usa solo protocollo 2
Protocol 2

# Cambia porta (security through obscurity)
Port 2222

# Timeout sessioni idle
ClientAliveInterval 300
ClientAliveCountMax 2

# Limita tentativi
MaxAuthTries 3

# Applica modifiche
sudo systemctl restart sshd

Fail2ban

# Installa fail2ban
sudo apt install fail2ban

# /etc/fail2ban/jail.local
[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600

# Riavvia
sudo systemctl restart fail2ban

Port Forwarding

Local Port Forwarding

# Accedi a servizio remoto via tunnel locale
ssh -L 8080:localhost:80 user@server
# Ora localhost:8080 punta a server:80

# Database remoto
ssh -L 5432:localhost:5432 user@db-server
# Connettiti a localhost:5432 per accedere al DB remoto

# Con configurazione
Host db-tunnel
    HostName db-server.example.com
    LocalForward 5432 localhost:5432

Remote Port Forwarding

# Esponi servizio locale su server remoto
ssh -R 8080:localhost:3000 user@server
# server:8080 punta a tuo-pc:3000

# Utile per webhook development, demo temporanee

Troubleshooting

Problemi Comuni

# "Permission denied (publickey)"
# 1. Verifica permessi
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

# 2. Debug connessione
ssh -vvv user@server 2>&1 | grep -i auth

# 3. Verifica chiave corretta
ssh-add -l

# "Too many authentication failures"
ssh -o IdentitiesOnly=yes -i ~/.ssh/chiave user@server

# "Host key verification failed"
# Rimuovi vecchia chiave
ssh-keygen -R hostname

# Agent forwarding non funziona
ssh -A user@server  # Abilita forwarding
echo $SSH_AUTH_SOCK  # Verifica sul server

Strumenti Correlati

Per lavorare con SSH e sicurezza:

• Hash Generator - Genera e verifica hash
• Base64 Encoder - Codifica chiavi e certificati
• UUID Generator - Genera identificatori unici

Conclusione

SSH è essenziale per lo sviluppo e l'amministrazione moderna. Punti chiave:

• Ed25519: Preferisci per nuove chiavi (RSA 4096 per compatibilità)
• Passphrase: Proteggi la chiave privata con una passphrase forte
• SSH Agent: Usa l'agent per non dover ripetere la passphrase
• Config: Configura ~/.ssh/config per semplificare le connessioni
• Hardening: Disabilita password authentication sui server

Per altri strumenti utili, esplora i nostri tool online gratuiti. Per documentazione completa, consulta OpenSSH Manual.