Comprendere l'Autenticazione con Chiave SSH: Chiavi Pubbliche e Private Spiegate

L'autenticazione con chiave SSH è il metodo normale con cui molti amministratori, sviluppatori, sistemi CI e strumenti di distribuzione accedono ai server. Il tuo laptop conserva una chiave privata, il server memorizza la chiave pubblica corrispondente e SSH dimostra che possiedi la chiave privata senza inviarla attraverso la rete.

Quest'ultima parte è il punto centrale. Una password è un segreto che digiti in molti posti. Una chiave privata è un segreto che dovrebbe rimanere sulla tua macchina. Se la proteggi con una passphrase e memorizzi solo la chiave pubblica sui server, ottieni un metodo di accesso che è sia più sicuro che più facile da automatizzare rispetto alle password condivise.

Il Problema con le Password

L'autenticazione tradizionale basata su password si basa su un segreto condiviso: la password. Sebbene password forti possano fornire un livello decente di sicurezza, sono suscettibili a diverse debolezze:

Attacchi di forza bruta: Gli aggressori possono provare innumerevoli combinazioni di password fino a indovinare quella corretta.
Attacchi dizionario: Usando parole o frasi comuni, gli aggressori possono compromettere rapidamente gli account.
Keylogger: Software malevolo può catturare le sequenze di tasti, rivelando le password.
Phishing: Tattiche di ingegneria sociale possono indurre gli utenti a rivelare le loro credenziali.
Errore umano: Gli utenti spesso scelgono password deboli, prevedibili o riutilizzate, e possono accidentalmente esporle.

L'autenticazione con chiave SSH riduce questi rischi perché il segreto privato non viene digitato sul server remoto. Questo non rende le chiavi magiche. Una chiave privata rubata e non crittografata può ancora essere abusata, e un file authorized_keys mal gestito può diventare un backdoor silenzioso.

Autenticazione con Chiave SSH: Una Panoramica

L'autenticazione con chiave SSH sfrutta la crittografia asimmetrica, un sistema che utilizza una coppia di chiavi matematicamente collegate: una chiave pubblica e una chiave privata. A differenza della crittografia simmetrica, dove la stessa chiave viene utilizzata sia per la crittografia che per la decrittografia, la crittografia asimmetrica utilizza una chiave per la crittografia e una diversa, ma correlata, per la decrittografia.

Quando ti connetti con le chiavi, il server verifica se il tuo account si fida della chiave pubblica offerta. Il tuo client firma quindi i dati di autenticazione con la chiave privata corrispondente. Il server verifica quella firma con la chiave pubblica. La chiave privata non viene caricata sul server.

Il Duo Crittografico: Chiavi Pubbliche e Private

Al centro dell'autenticazione con chiave SSH ci sono questi due componenti distinti ma interconnessi.

La Chiave Privata

La chiave privata è la tua identità segreta. È una lunga e complessa stringa di caratteri che deve essere tenuta assolutamente confidenziale e mai condivisa con nessuno. Pensala come la chiave unica per la tua cassaforte digitale.

Critica per la Sicurezza: Se la tua chiave privata viene compromessa, un aggressore potrebbe impersonarti e ottenere accesso non autorizzato a qualsiasi server dove è stata distribuita la corrispondente chiave pubblica.
Posizione: Tipicamente memorizzata sulla tua macchina locale (es. ~/.ssh/id_rsa, ~/.ssh/id_ed25519).
Protezione: Può essere protetta da una passphrase. Se qualcuno copia il file della chiave, la passphrase è la barriera extra tra "file rubato" e "accesso al server rubato".

La Chiave Pubblica

La chiave pubblica è la controparte della tua chiave privata. È derivata dalla tua chiave privata ma non può essere utilizzata per ricreare la chiave privata. Come suggerisce il nome, la chiave pubblica è destinata a essere condivisa e posizionata su qualsiasi server a cui desideri accedere.

Condivisibile: Puoi distribuire in sicurezza la tua chiave pubblica a chiunque o a qualsiasi server senza compromettere la tua sicurezza.
Posizione: Sul server, le chiavi pubbliche sono tipicamente memorizzate nel file ~/.ssh/authorized_keys per ogni account utente. Ogni riga in questo file rappresenta una chiave pubblica di fiducia.
Ruolo: La chiave pubblica permette al server di verificare una firma fatta dalla corrispondente chiave privata.

Come Funziona l'Autenticazione con Chiave SSH: L'Handshake

Analizziamo il processo passo-passo di come l'autenticazione con chiave SSH stabilisce una connessione sicura:

Generazione della Coppia di Chiavi: Per prima cosa, generi una coppia di chiavi pubblica e privata sulla tua macchina locale. La chiave privata rimane segreta e la chiave pubblica è ciò che distribuirai.
Distribuzione della Chiave Pubblica: Copi la tua chiave pubblica sul server remoto a cui vuoi accedere. Questa chiave viene tipicamente aggiunta al file ~/.ssh/authorized_keys nella directory home del tuo utente sul server.
Tentativo di Connessione: Quando avvii una connessione SSH dalla tua macchina locale al server remoto, il tuo client SSH indica che vuole autenticarsi usando una chiave.
Controllo del Server: Il server verifica se la chiave pubblica offerta è consentita per quell'utente.
Prova del Client: Il tuo client firma i dati di autenticazione con la chiave privata. Se la chiave privata ha una passphrase, potrebbe esserti chiesto di sbloccarla localmente.
Verifica: Il server verifica la firma usando la chiave pubblica da authorized_keys. Se la firma è valida e l'account è autorizzato ad accedere, l'autenticazione ha successo.
Autenticazione Concessa: Se la verifica ha successo, il server ti concede l'accesso e viene stabilita una sessione SSH sicura.

Fondamentalmente, la tua chiave privata non lascia mai la tua macchina locale durante tutto questo processo. Vengono scambiate solo prove crittografiche derivate da essa.

Generare una Coppia di Chiavi SSH

Generare una coppia di chiavi SSH è un processo semplice usando il comando ssh-keygen sulla tua macchina locale (Linux, macOS o WSL/Git Bash su Windows).

ssh-keygen -t ed25519 -C "[email protected]"

-t ed25519: Specifica il tipo di chiave da creare. Ed25519 è un moderno predefinito per la maggior parte delle nuove chiavi OpenSSH. RSA è ancora comune, specialmente intorno a sistemi più vecchi.
-C "[email protected]": Aggiunge un commento alla chiave pubblica, che ti aiuta a identificarne lo scopo o il proprietario.

Ti verrà chiesto un file dove salvare la chiave (predefinito è ~/.ssh/id_ed25519) e una passphrase. Usa sempre una passphrase forte per proteggere la tua chiave privata.

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

Dopo la generazione, avrai due file nella tua directory ~/.ssh:

id_ed25519 (la tua chiave privata)
id_ed25519.pub (la tua chiave pubblica)

Assicurati che il file della chiave privata abbia permessi rigorosi:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519

Distribuire la Tua Chiave Pubblica

Per utilizzare l'autenticazione con chiave, la tua chiave pubblica deve essere posizionata sul server remoto a cui desideri accedere.

Usando `ssh-copy-id` (Consigliato)

L'utilità ssh-copy-id è il modo più semplice e sicuro per distribuire la tua chiave pubblica. Gestisce la creazione della directory ~/.ssh e del file authorized_keys con i permessi corretti se non esistono.

ssh-copy-id -i ~/.ssh/id_ed25519.pub utente@host_remoto

Sostituisci utente con il tuo nome utente sul server remoto e host_remoto con l'indirizzo IP o il nome host del server. Ti verrà chiesta la tua password per utente@host_remoto un'ultima volta per caricare la chiave.

Distribuzione Manuale

Se ssh-copy-id non è disponibile, puoi copiare la chiave pubblica manualmente:

Copia il contenuto della chiave pubblica: Visualizza la tua chiave pubblica usando cat.
```
cat ~/.ssh/id_ed25519.pub
```
Copia l'intero output, che inizia con ssh-ed25519 ... e termina con il tuo commento.
Connettiti tramite SSH al server remoto usando l'autenticazione con password:
```
ssh utente@host_remoto
```
Inserisci la tua password quando richiesto.

Crea la directory ~/.ssh e il file authorized_keys se non esistono:

mkdir -p ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Aggiungi la tua chiave pubblica a authorized_keys: Incolla il contenuto della chiave pubblica che hai copiato in precedenza nel file authorized_keys.
```
echo "ssh-ed25519 AAAA..." >> ~/.ssh/authorized_keys
```
(Sostituisci ssh-ed25519 AAAA... con il contenuto effettivo della tua chiave pubblica)

Connettersi con le Chiavi SSH

Una volta che la tua chiave pubblica è sul server, puoi connetterti semplicemente specificando l'utente e l'host:

ssh utente@host_remoto

Se hai più coppie di chiavi o la tua chiave privata non si trova nella posizione predefinita (~/.ssh/id_rsa o ~/.ssh/id_ed25519), potresti doverla specificare usando l'opzione -i:

ssh -i ~/.ssh/mia_chiave_personalizzata utente@host_remoto

Se la tua chiave privata è protetta da una passphrase, ti verrà chiesto di inserirla. Per evitare di inserire la passphrase ripetutamente durante una sessione, puoi usare ssh-agent.

Vantaggi di Sicurezza dell'Autenticazione con Chiave SSH

Riduce il rischio di indovinare la password: Se l'accesso con password è disabilitato, gli aggressori non possono fare brute force su quell'account tramite password SSH.
Credenziali più forti: Una chiave SSH generata correttamente non è qualcosa che un umano può indovinare.
Nessun caricamento della chiave privata: La tua chiave privata rimane locale durante l'autenticazione.
Amichevole per l'Automazione: Le chiavi permettono accessi scriptabili e senza password, essenziali per strumenti di automazione e pipeline CI/CD.
Protezione con Passphrase: Aggiungere una passphrase alla tua chiave privata fornisce un ulteriore livello di sicurezza. Anche se il file della chiave privata viene rubato, rimane inutilizzabile senza la passphrase.

Gestire le Tue Chiavi SSH

`ssh-agent`

ssh-agent è un programma che viene eseguito in background e mantiene in memoria le tue chiavi private decifrate. Quando tenti di connetterti a un server SSH, il tuo client SSH può interrogare ssh-agent per la chiave privata necessaria, eliminando la necessità di digitare ripetutamente la passphrase.

Per avviare ssh-agent e aggiungere la tua chiave:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Inserirai la tua passphrase una volta quando aggiungi la chiave all'agente.

Denominazione e Organizzazione delle Chiavi

Per gestire più chiavi (es. per diverse organizzazioni, progetti o uso personale), considera l'uso di nomi significativi:

ssh-keygen -t ed25519 -f ~/.ssh/id_lavoro_progetto -C "chiave_progetto_lavoro"
ssh-keygen -t ed25519 -f ~/.ssh/id_personale_github -C "chiave_personale_github"

Puoi quindi specificare quale chiave usare con l'opzione -i, o configurare il tuo file ~/.ssh/config per selezionare automaticamente la chiave corretta in base all'host.

Esempio di ~/.ssh/config:

Host github.com
    IdentityFile ~/.ssh/id_personale_github
    User git

Host server-lavoro
    Hostname 192.168.1.100
    IdentityFile ~/.ssh/id_lavoro_progetto
    User utente_sviluppo

Migliori Pratiche e Suggerimenti

Non condividere mai la tua chiave privata: Questa è la regola d'oro. La tua chiave privata è la tua identità digitale.
Usa una passphrase forte: Proteggi la tua chiave privata con una passphrase robusta, simile a una password forte. Questo rende la tua chiave inutile anche se cade nelle mani sbagliate.
Ruota quando c'è una ragione: Genera una nuova chiave quando un dispositivo viene perso, un collaboratore se ne va, una chiave è stata condivisa per errore, o un vecchio algoritmo non soddisfa più la tua politica.
Limita i permessi dei file: Assicurati che il file della chiave privata abbia permessi 600 (rw-------) e la tua directory ~/.ssh abbia 700 (rwx------).
Disabilita l'autenticazione con password con attenzione: Una volta che l'accesso con chiave funziona da un secondo terminale, molti server dovrebbero impostare PasswordAuthentication no in /etc/ssh/sshd_config. Mantieni l'accesso alla console disponibile prima di cambiare questo sui sistemi remoti.
Usa ssh-agent: Per comodità e sicurezza, usa ssh-agent per gestire le tue chiavi, specialmente quelle con passphrase.

Un Modello Mentale Semplice

La chiave pubblica è la serratura che installi sull'account del server. La chiave privata è la credenziale che tieni sulla tua macchina. La passphrase protegge quella credenziale se il file viene copiato. Il file authorized_keys è la lista di accesso.

La maggior parte dei problemi con le chiavi SSH deriva dal confonderle: copiare la chiave privata sul server, incollare la chiave pubblica sotto l'utente sbagliato, usare il file di identità sbagliato, o lasciare i permessi troppo aperti perché OpenSSH possa fidarsi. Denomina le chiavi per scopo, proteggi le chiavi private con passphrase, usa ssh-agent per comodità, rimuovi le vecchie chiavi pubbliche quando l'accesso dovrebbe terminare, e testa le modifiche da un secondo terminale prima di disabilitare l'accesso con password.