Difference between revisions of "SSH keys (Italiano)"

Revision as of 20:10, 7 March 2011

Cosa sono le chiavi SSH?

Utilizzando le chiavi SSH (una chiave pubblica ed una privata per la precisione), si può facilmente connettersi a un server o più server, senza dover inserire la password per ogni sistema.

È possibile impostare le chiavi senza password, tuttavia questo approccio non è raccomandabile, dato che se qualcuno scopre le chiavi le potrebbe utilizzare. Questa guida descrive come configurare un sistema in modo che le passphrase vengano ricordate in modo sicuro.

Generare la chiavi SSH

Se OpenSSH non è già installato sul sistema, provvedere con, dato che adesso non è installato di default su Arch.

# pacman -S openssh

Le chiavi possono essere generate eseguendo il comando Template:Codeline come utente:

$ ssh-keygen -b 521 -t ecdsa
Generating public/private ecdsa key pair.
Enter file in which to save the key (/home/mith/.ssh/id_ecdsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/mith/.ssh/id_ecdsa.
Your public key has been saved in /home/mith/.ssh/id_ecdsa.pub.
The key fingerprint is:
3a:43:37:6d:e2:5b:97:e2:6f:e2:80:f9:23:97:70:0c mith@middleearth

Verrà chiesto di specificare un percorso (che si dovrebbe lasciare come di default), comunque l'importante è la passphrase. Verranno tralasciate in questa guida, le regole per una buona passphrase, dando per scontato che le si conoscano.

Cosa è successo? Ciò che si è appena ottenuto è una coppia di chiavi a 521 bit di lunghezza (Template:Codeline) ECDSA pubblica/privata (Template:Codeline) con il comando Template:Codeline.

La crittografia ECDSA(Elliptic Curve Digital Signature Algorithm) fornisce chiavi di dimensioni inferiori ed operazioni più veloci mantenendo alto il livello di sicurezza.Viene introdotto come metodo preferito dalla versione 5.7 di OpenSSH. Le chiavi ECDSA potrebbero non essere compatibili con sistemi che utilizzano verisoni più vecchie di OpenSSH.

Se si desidera creare una coppia di chiavi RSA(da 2048 a 4096 bit di lunghezza) oppure DSA(1024 bit), anzichè ECDSA, usare Template:Codeline oppure Template:Codeline e non dimenticare di incrementare la dimensione delle chiavi; eseguire Template:Codeline senza l'opzione Template:Codeline fornirà comunque chiavi di dimensioni ragionevoli.

Copiare le chiavi al server remoto

Ora che si sono generate le chiavi, bisogna copiarle sul server remoto. Per impostazione predefinita di OpenSSH, la chiave pubblica deve essere concatenata in Template:Filename.

$ scp ~/.ssh/id_ecdsa.pub mith@metawire.org:

Questo comando copia la chiave pubblica (Template:Codeline) sul server remoto tramite scp (notare il Template:Codeline alla fine dell'indirizzo del server). Il file finisce nella cartella home, ma è comunque possibile specificare un altro percorso.

A continuazione, sul server remoto, è necessario creare la cartella Template:Filename se non esiste, e concatenare il file chiave Template:Filename:

$ ssh mith@metawire.org
mith@metawire.org's password:
$ mkdir ~/.ssh
$ cat ~/id_ecdsa.pub >> ~/.ssh/authorized_keys
$ rm ~/id_ecdsa.pub
$ chmod 600 ~/.ssh/authorized_keys

Gli ultimi due comandi rimuovono la chiave pubblica dal server (non necessaria adesso), e ne definisce i permessi corretti sul file Template:Filename.

Se ora ci si disconnette dal server, e si prova a ricollegarsi, dovrebbe venire richiesta la passphrase della chiave:

$ ssh mith@metawire.org
Enter passphrase for key '/home/mith/.ssh/id_ecdsa':

Se non è possibile effettuare il login con la chiave, controllare i permessi sul file Template:Filename.

Controllare anche i permessi della cartella Template:Filename, che non dovrebbe avere permessi di scrittura per "group" e "other". Eseguire il seguente comando per disattivare i permessi di scrittura di "group" e "other" alla cartella Template:Filename:

$ chmod go-w ~/.ssh

Memorizzare le passphrase delle chiavi

Ora si può accedere ai propri server utilizzando una chiave invece di una password, ma è realmente più facile, dal momento che c'è ancora bisogno di immettere la key passphrase? La risposta è quella di utilizzare un agente SSH, un programma che ricorda la passphrase delle proprie chiavi! C'è un certo numero di strumenti a disposizione, quindi fare una ricerca e scegliere quello che sembra più adatto alle proprie esigenze.

ssh-agent

ssh-agent è l'agente predefinito fornito da OpenSSH.

$ ssh-agent
SSH_AUTH_SOCK=/tmp/ssh-vEGjCM2147/agent.2147; export SSH_AUTH_SOCK;
SSH_AGENT_PID=2148; export SSH_AGENT_PID;
echo Agent pid 2148;

Quando si esegue Template:Codeline verranno stampate le variabili d'ambiente che si stanno per utilizzare. Per usufruire di queste variabili eseguire il comando tramite Template:Codeline.

$ eval `ssh-agent`
Agent pid 2157

È possibile aggiungere il seguente comando al file Template:Filename in modo che venga eseguito ogni volta che si apre una nuova sessione:

$ echo 'eval `ssh-agent`' >> /etc/profile

Notare le differenti virgolette, alcune sono apici, altre sono virgolette arricciate!

Ora che Template:Codeline è in esecuzione, bisognerà istruirlo sull'esistenza di una chiave privata e relativa ubicazione.

$ ssh-add ~/.ssh/id_ecdsa
Enter passphrase for /home/user/.ssh/id_ecdsa:
Identity added: /home/user/.ssh/id_ecdsa (/home/user/.ssh/id_ecdsa)

Viene richiesta la passphrase, la si immette, ed è finito. Ora si può accedere al server remoto senza dover inserire la password, mentre la chiave privata viene protetta da password.

L'unico aspetto negativo è che una nuova istanza di ssh-agent deve essere creata per ogni nuova console (shell) aperta, il che significa che è necessario eseguire ssh-add ogni volta su ogni console. C'è una soluzione a questo inconveniente con un programma, o meglio uno script chiamato keychain che è illustrato nella sezione successiva.

Uso di GnuPG Agent

L'agente GnuPG, distribuito con il pacchetto Template:Package Official, ha un agente di emulazione OpenSSH. Se si utilizza GPG si potrebbe considerare l'utilizzo di questo agente per la salvaguardia delle proprie chiavi. Altrimenti si potrebbe gradire la voce di dialogo PIN che fornisce una propria gestione passphrase, e che è una cosa differente dal portachiavi.

Per iniziare a utilizzare l'agente GPG per le proprie chiavi SSH si deve prima iniziare la gpg-agent con l'opzione Template:Codeline. Esempi(non dimenticare di rendere eseguibile il file): Template:File

Una volta che gpg-agent è in esecuzione si può usare ssh-add per approvare le chiavi, proprio come con un ssh-agent semplice. L'elenco delle chiavi approvate è memorizzato nel file Template:Filename. Una volta che la chiave è approvata, si aprirà una finestra di dialogo per l'immissione del PIN ogni volta che è necessaria la password. È possibile controllare le passphrase nel file Template:Filename. L'esempio seguente mantiene la cache delle chiavi di gpg-agent per 3 ore:

 # Cache settings
 default-cache-ttl 10800
 default-cache-ttl-ssh 10800

Altre opzioni utili per questo file sono ad esempio, il programma di inserimento del PIN (GTK, QT o versione ncurses), keyboard grabbing, eccetera:

 # Environment file
 write-env-file /home/username/.gnupg/gpg-agent.info
 
 # Keyboard control
 #no-grab
   
 # PIN entry program
 #pinentry-program /usr/bin/pinentry-curses
 #pinentry-program /usr/bin/pinentry-qt4
 pinentry-program /usr/bin/pinentry-gtk-2

Utilizzo di portachiavi

Keychain gestisce una o più chiavi private specifiche. Quando avviato richiederà la passphrase per la chiave (o chiavi) privata e la memorizzerà. In questo modo la chiave privata sarà protetta dalla password, ma non la si dovrà inserire ripetutamente.

Installare keychain dal repository extra:

# pacman -S keychain

Creare il seguente file e renderlo eseguibile: Template:File

Oppure

Template:File

Oppure

Aggiungere

eval `keychain --eval --agents ssh id_ecdsa`

al proprio Template:Filename o in Template:Filename(se si usa Template:Package Official come shell di default).

In caso, sostituire Template:Filename con Template:Filename. Per coloro che usano una shell non compatibile con bash, vedere Template:Filename o Template:Filename per maggiori informazioni sulle altre shell.

Chiudere la shell ed avviarla di nuovo. Dovrebbe apparire il portachiavi e se è il primo avvio realizzato, verrà richiesta la passphrase della chiave privata specifica.

Consultare anche la sezione seguente per usare il portachiavi durante una sessione X. Chiaramente non sarà necessario usaer ssh-agent manualmente. Basterà installare una variante di x11-ask-keypass.

Utilizzo di ssh-agent e x11-ssh-askpass

È necessario avviare ssh-agent ogni volta che si avvia una nuova sessione di X. Ssh-agent verrà spento al termine della sessione X.

Installare una variante di x11-ssh-askpass, che chiederà la password ogni volta che si apre un nuova sessione di X. Altrimenti usare l'originale x11-ssh-askpass da AUR oppure usare Template:Package Official (che utilizza Template:Package Official):

# pacman -S ksshaskpass

oppure Template:Package Official (utilizza le qt):

# pacman -S openssh-askpass

Dopo aver installato il pacchetto, chiudendo la sessione X ed effettuando nuovamente l'accesso verrà richiesta la password all'avvio della sessione X senza doverla immettere successivamente.

GNOME Keyring

Se si utilizza il desktop GNOME, lo strumento GNOME Keyring può essere usato come agente SSH. La configurazione è semplice, per prima cosa installare:

# pacman -S gnome-keyring

Poi si devono aggiungere le proprie chiavi SSH, ed inserire la parola chiave.

$ ssh-add ~/.ssh/id_ecdsa
Enter passphrase for /home/mith/.ssh/id_ecdsa:

Quando ci si connette ad un server, la chiave verrà rilevata e una finestra di dialogo richiederà la passphrase. C'è un'opzione per sbloccare la chiave automaticamente quando si effettua il login. Se la si seleziona, non sarà necessario inserire la password di nuovo.

Risoluzione dei problemi

Se sebra che il server SSH stia ingorando le vostre chiave, assicarartevi che i permessi siano corretti sui file interessati.

Per la macchina locale:

$ chmod 700 ~/
$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh/id_rsa

Per la macchina remota:

$ chmod 700 ~/
$ chmod 700 ~/.ssh
$ chmod 600 ~/.ssh/authorized_keys

Se anche questo non aiuta, lanciare il demone Template:Codeline in modaltà debug e monitorare l'output durante la connessione:

# /usr/sbin/sshd -d

Link utili / Informazioni

• HOWTO: set up ssh keys
• OpenSSH key management, Part 1
• OpenSSH key management, Part 2
• OpenSSH key management, Part 3
• Getting started with SSH
• Manual Pages: ssh-keygen(1)