Difference between revisions of "SSH keys (Italiano)"

From ArchWiki
Jump to: navigation, search
(Uso di GnuPG Agent)
(Using keychain)
Line 133: Line 133:
 
   pinentry-program /usr/bin/pinentry-gtk-2
 
   pinentry-program /usr/bin/pinentry-gtk-2
  
=== Using keychain ===
+
=== Utilizzo di portachiavi ===
[http://www.gentoo.org/proj/en/keychain/index.xml Keychain] manages one or more specified private keys. When initialized it will ask for the passphrase for the private key(s) and store it. That way your private key is password protected but you won't have to enter your password over and over again.
+
[http://www.gentoo.org/proj/en/keychain/index.xml Keychain] gestisce una o più chiavi private specifiche. Quando inizializzato richiederà la passphrase per la chiave (o chiavi) privata e la memorizzerà. In questo modo la chiave privata sarà protetta dalla password, ma non si dovrà inserire ripetutamente la password.
  
Install keychain from the extra repo:
+
Installare keychain dal repository extra:
 
   
 
   
 
  # pacman -S keychain
 
  # pacman -S keychain
  
Add to {{Filename|~/.bashrc}} or {{Filename|~/.zshrc}} the following:
+
Aggiungere a {{Filename|~/.bashrc}} o {{Filename|~/.zshrc}} il seguente:
 
   
 
   
 
  eval `keychain --eval --nogui -Q -q id_rsa`
 
  eval `keychain --eval --nogui -Q -q id_rsa`
  
Or
+
Oppure
  
 
  /usr/bin/keychain -Q -q --nogui ~/.ssh/id_dsa
 
  /usr/bin/keychain -Q -q --nogui ~/.ssh/id_dsa
 
  <nowiki>[[ -f $HOME/.keychain/$HOSTNAME-sh ]]</nowiki> && source $HOME/.keychain/$HOSTNAME-sh
 
  <nowiki>[[ -f $HOME/.keychain/$HOSTNAME-sh ]]</nowiki> && source $HOME/.keychain/$HOSTNAME-sh
  
{{Tip| If you want greater security replace -Q with --clear but will be less convenient.}}
+
{{Tip| Se si desidera una maggiore sicurezza sostituire -Q con --clear ma sarà meno conveniente.}}
  
If necessary, replace {{Filename|~/.ssh/id_dsa}} with {{Filename|~/.ssh/id_rsa}}.  For those using a non-Bash compatible shell, see {{Filename|keychain --help}} or {{Filename|man keychain}} for details on other shells.
+
In caso, sostituire {{Filename|~/.ssh/id_dsa}} con {{Filename|~/.ssh/id_rsa}}.  Per coloro che usano una shell non-compatibile con bash, vedere {{Filename|keychain --help}} o {{Filename|man keychain}} per maggiori informazioni sulle altre shell.
  
Close your shell and open it again. Keychain should come up and if it's your first run it will ask your for the passphrase of the specified private key.
+
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.
  
 
=== Using ssh-agent and x11-ssh-askpass ===
 
=== Using ssh-agent and x11-ssh-askpass ===

Revision as of 16:48, 12 July 2010


Tango-preferences-desktop-locale.pngThis article or section needs to be translated.Tango-preferences-desktop-locale.png

Notes: please use the first argument of the template to provide more detailed indications. (Discuss in Talk:SSH keys (Italiano)#)

Cosa sono le chiavi SSH?

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

Note È 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 vengono ricordate in modo sicuro.

Generare la chiavi SSH

Se OpenSSH non è già installato sul sistema, provvedere ora con:

# pacman -S openssh

Le chiavi possono essere generate eseguendo il comando ssh-keygen come utente:

$ ssh-keygen -b 1024 -t dsa
Generating public/private dsa key pair.
Enter file in which to save the key (/home/mith/.ssh/id_dsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/mith/.ssh/id_dsa.
Your public key has been saved in /home/mith/.ssh/id_dsa.pub.
The key fingerprint is:
x6:68:xx:93:98:8x:87:95:7x:2x:4x:x9:81:xx:56:94 mith@middleearth

Verrà chiesto di specificare un percorso (che si dovrebbe lasciare come di default), comunque è la frase il bit importante! Tralasceremo, in questa guida, le regole per una buona passphrase, dando per scontato che le si sappiano.

Allora, cosa si ha appena fatto? Si ha generato una coppia di chiavi a 1024 bit di lunghezza (-b 1024) dsa pubblica/privata (-t dsa) con il comando ssh-keygen.

Se si desidera creare una coppia di chiavi RSA invece di dsa, usare -t rsa (non specificare la lunghezza della chiave "-b" come lunghezza predefinita, per rsa il default equivale a 2048, ed è sufficiente).

Copiare le chiavi al server remoto

Ora che si sono generatoe le chiavi, bisogna copiarle al server remoto. Per impostazione predefinita di OpenSSH, la chiave pubblica deve essere concatenata in ~/.ssh/authorized_keys.

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

Questa operazione copia la chiave pubblica (id_dsa.pub) al server remoto tramite scp (notare il : 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 ~/.ssh se non esiste, e concatenare il file chiave authorized_keys:

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

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

Se ora ci si disconnette dal server, e si tenta di riconnettersi, dovrebbe venire richiesta la passphrase della chiave:

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

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

Controllate anche i permessi della cartella ~/.ssh, 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 ~/.ssh:

$ 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 vostre chiavi! C'è un certo numero di diversi strumenti a disposizione, quindi fare una ricerca e scegliere quella 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 ssh-agent verranno stampate quali variabili d'ambiente verranno usate... Per usufruire di queste variabili eseguire il comando tramite eval.

$ eval `ssh-agent`
Agent pid 2157

È possibile aggiungere il seguente comando al proprio .bashrc in modo che venga eseguito ogni volta che si crea una nuova shell:

$ echo 'eval `ssh-agent`' >> ~/.bashrc

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

Ora che il ssh-agent è in esecuzione, bisognerà istruirlo sull'esistenza di una chiave privata e sulla sua ubicazione.

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

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) che si apre, 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 gnupg2, 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 --enable-ssh-support. Lo si può fare dal proprio ~/.xinitrc o dal file di profilo della shell per avviarlo con la sessione. Codice di esempio per iniziare gpg-agent:

 # Start the GnuPG agent and enable OpenSSH agent emulation
 gnupginf="${HOME}/.gnupg/gpg-agent.info"
 
 if ( pgrep -u "${USER}" gpg-agent ); then
     eval `cat $gnupginf`
     eval `cut -d= -f1 $gnupginf | xargs echo export`
 else
     eval `gpg-agent --enable-ssh-support --daemon`
 fi

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 ~/.gnupg/sshcontrol. 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 ~/.gnupg/gpg-agent.conf. 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 impostazioni utili per questo file sono il programma di inserimento del PIN (GTK, QT o versione ncurses), keyboard grabbing, ed altri ancora...:

 # 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 inizializzato richiederà la passphrase per la chiave (o chiavi) privata e la memorizzerà. In questo modo la chiave privata sarà protetta dalla password, ma non si dovrà inserire ripetutamente la password.

Installare keychain dal repository extra:

# pacman -S keychain

Aggiungere a Template:Filename o Template:Filename il seguente:

eval `keychain --eval --nogui -Q -q id_rsa`

Oppure

/usr/bin/keychain -Q -q --nogui ~/.ssh/id_dsa
[[ -f $HOME/.keychain/$HOSTNAME-sh ]] && source $HOME/.keychain/$HOSTNAME-sh
Tip: Se si desidera una maggiore sicurezza sostituire -Q con --clear ma sarà meno conveniente.

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.

Using ssh-agent and x11-ssh-askpass

You need to start the ssh-agent everytime you start a new Xsession. The ssh-agent will be closed when the X session ends.

Install x11-ssh-askpass which will ask your passphrase everytime you open a new Xsession:

# pacman -S x11-ssh-askpass

Prepend this into your ~/.xsession:

eval `/usr/bin/ssh-agent`
SSH_ASKPASS=/usr/lib/openssh/x11-ssh-askpass ssh-add < /dev/null
# then the end of the file with for example "exec dwm"

GNOME Keyring

If you use the GNOME desktop, the GNOME Keyring tool can be used as an SSH agent. Setup is simple, first install it:

# pacman -S gnome-keyring

Next you need to add your SSH keys, and enter the passphrase.

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

Now when you connect to a server, the key will be found and a dialog will popup asking you for the passphrase. It has an option to automatically unlock the key when you login. If you check this you won't need to enter your passphrase again!

PuTTY

The above procedure is a bit complicated when using PuTTY on Windows since PuTTY can't directly use keys generated by ssh-keygen. The private key needs to be converted using PuTTYgen which you can find here. The procedure is then as follows:

  1. Generate a 1024 bit RSA encrypted key pair with ssh-keygen on you Linux computer (you can log in with your usual username/password using PuTTY)
  2. Add the public key to the ~/.ssh/authorized_keys file
  3. Move the private key to the Windows machine
  4. Load the private key with PuTTYgen and click Save private key. This will convert the key so that PuTTY can use it.
  5. Start PuTTY, go to SSH->Auth and find the private key. Then simply connect to your Linux machine. You will be prompted for your username and passphrase (if you chose to enter one when you generated the keys).

Note that reversing the procedure, that is, generating the key pair with PuTTYgen and converting the public key with ssh-keygen, will NOT work.

Useful Links / Information