Difference between revisions of "SSH keys (Italiano)"

From ArchWiki
Jump to: navigation, search
(Using ssh-agent and x11-ssh-askpass)
(rm temporary i18n template)
(43 intermediate revisions by 6 users not shown)
Line 1: Line 1:
[[Category:Networking (Italiano)]]
+
[[Category:Secure Shell (Italiano)]]
[[Category:Security (Italiano)]]
+
[[en:SSH Keys]]
[[Category:HOWTOs (Italiano)]]
+
[[es:SSH Keys]]
 +
[[ru:SSH Keys]]
 +
[[sr:SSH Keys]]
 +
[[tr:SSH_Anahtarları]]
 +
[[zh-CN:SSH Keys]]
 +
{{Out of date|Questa pagina è in fase di revisione e potrebbe non essere aggiornata. Seguite per ora le istruzioni della versione inglese.|Talk:ArchWiki Translation Team (Italiano)#Pagine Marcate come "out of date" e "Traslateme"}}
 +
Le chiavi SSH sono una implementazione della [[Wikipedia:Public-key cryptography|crittografia a chiavi pubbliche]]. Esse risolvono il problema degli attacchi di tipo brute-force sulle password rendendoli impraticabili.In aggiunta, usando le chiavi SSH, si può facilmente connettersi a un server o più server, senza dover inserire la password per ogni sistema.
  
{{translateme}}
+
È 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 la passphrase venga usata per criptare la chiave privata e che debba essere inserita per utilizzare la chiave stessa.
  
= Cosa sono le chiavi SSH? =
+
==Generare la chiavi SSH==
 +
Se {{Pkg|openssh}} non è già installato sul sistema, provvedere [[Pacman (Italiano)|installandolo]], dato che adesso non è installato di default su Arch.
  
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.
+
Le chiavi possono essere generate eseguendo il comando {{ic|ssh-keygen}} come utente:
  
'''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.
+
{{hc|1=$ ssh-keygen -b 521 -t ecdsa -C"$(id -un)@$(hostname)-$(date --rfc-3339=date)"
 +
|2=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}}
  
== Generare la chiavi SSH ==
+
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.
  
Se OpenSSH non è già installato sul sistema, provvedere ora con:
+
Cosa è successo? Ciò che si è appena ottenuto è una coppia di chiavi a 521 bit di lunghezza ({{ic|-b 521}}) ECDSA pubblica/privata ({{ic|-t ecdsa}}) contenente un commento con alcune informazioni ({{ic|-C"$(id -un)"@$(hostname)-$(date --rfc-3339=date)}}) tramite il comando {{ic|ssh-keygen}}.
  
# pacman -S openssh
+
{{Nota|Queste chiavi verranno usate solo per l'autenticazione, la scelta di chiavi più grandi non determinerà un maggiore carico per la CPU nel trasferimento dei dati via SSH.}}
  
Le chiavi possono essere generate eseguendo il comando ssh-keygen come utente:
+
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, vedere [http://openssh.org/txt/release-5.7 OpenSSH 5.7 Note di rilascio]. Le chiavi ECDSA potrebbero non essere compatibili con sistemi che utilizzano versioni più vecchie di OpenSSH.
  
$ ssh-keygen -b 1024 -t dsa
+
Se si desidera creare una coppia di chiavi RSA(da 2048 a 4096 bit di lunghezza) oppure DSA(1024 bit), anziché ECDSA, usare {{ic|-t rsa}} oppure {{ic|-t dsa}} e non dimenticare di incrementare la dimensione delle chiavi; eseguire {{ic|ssh-keygen}} senza l'opzione {{ic|-b}} solitamente fornirà comunque chiavi di dimensioni ragionevoli.
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.
+
==Copiare la chiave pubblica al server remoto==
 +
Ora che sono state generate le chiavi, bisogna copiarle la chiave pubblica ({{ic|*.pub}}) sul server remoto. (La chiave privata viene mantenuta sul pc da cui verrà effettuata la connessione.)
  
Allora, cosa si ha appena fatto? Si ha generato una coppia di chiavi a 1024 bit di lunghezza (<code>-b 1024</code>) dsa pubblica/privata (<code>-t dsa</code>) con il comando <code>ssh-keygen</code>.
+
===Metodo semplice===
 +
{{Nota|Se si utilizza un Ternimal su un Mac, sarà necessario [http://phildawson.tumblr.com/post/484798267/ssh-copy-id-in-mac-os-x installare ssh-copy-id] prima di procedere.}}
 +
Se il nome della chiave è {{ic|id_rsa.pub}} basterà semplicemente invocare il comando
 +
 +
$ ssh-copy-id tuo-server.org
 +
 
 +
oppure se si usa un nome utente differente dal proprio
 +
 
 +
$ ssh-copy-id nome-utente-per-accedere@tuo-server.org
 +
 
 +
Se il nome della chiave non è quello standard si otterrà il seguente errore: "/usr/bin/ssh-copy-id: ERROR: No identities found". In questo caso sarà necessario specificare esplicitamente il percorso della chiave:
 +
 
 +
$ ssh-copy-id -i ~/.ssh/id_ecdsa.pub nome-utente-per-accedere@tuo-server.org
  
Se si desidera creare una coppia di chiavi RSA invece di dsa, usare <code>-t rsa</code> (non specificare la lunghezza della chiave "-b" come lunghezza predefinita, per rsa il default equivale a 2048, ed è sufficiente).
+
Se necessario, è possibile specificare la porta nella dichiarazione dell'host:
  
== Copiare le chiavi al server remoto ==
+
$ ssh-copy-id -i ~/.ssh/id_rsa.pub '-p 221 nomeutente@host'
  
Ora che si sono generatoe le chiavi, bisogna copiarle al server remoto. Per impostazione predefinita di OpenSSH, la chiave pubblica deve essere concatenata in <code>~/.ssh/authorized_keys</code>.
+
===Metodo tradizionale===
 +
Per impostazione predefinita di OpenSSH, la chiave pubblica deve essere concatenata in {{ic|~/.ssh/authorized_keys}}.
  
  $ scp ~/.ssh/id_dsa.pub mith@metawire.org:
+
  $ scp ~/.ssh/id_ecdsa.pub mith@metawire.org:
  
Questa operazione copia la chiave pubblica (<code>id_dsa.pub</code>) al server remoto tramite scp (notare il '''<code>:</code>''' alla fine dell'indirizzo del server). Il file finisce nella cartella home, ma è comunque possibile specificare un altro percorso.
+
Questo comando copia la chiave pubblica ({{ic|id_dsa.pub}}) sul server remoto tramite scp (notare il '''{{ic|:}}''' 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:
+
A continuazione, sul server remoto, è necessario creare la cartella {{ic|~/.ssh}} se non esiste, e concatenare il file chiave {{ic|authorized_keys}}:
  
 
  $ ssh mith@metawire.org
 
  $ ssh mith@metawire.org
 
  mith@metawire.org's password:
 
  mith@metawire.org's password:
 
  $ mkdir ~/.ssh
 
  $ mkdir ~/.ssh
  $ cat ~/id_dsa.pub >> ~/.ssh/authorized_keys
+
  $ cat ~/id_ecdsa.pub >> ~/.ssh/authorized_keys
  $ rm ~/id_dsa.pub
+
  $ rm ~/id_ecdsa.pub
 
  $ chmod 600 ~/.ssh/authorized_keys
 
  $ 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.
+
Gli ultimi due comandi rimuovono la chiave pubblica dal server (non necessaria adesso), e ne definisce i permessi corretti sul file {{ic|authorized_keys}}.
  
Se ora ci si disconnette dal server, e si tenta di riconnettersi, dovrebbe venire richiesta la passphrase della chiave:
+
Se ora ci si disconnette dal server, e si prova a ricollegarsi, dovrebbe venire richiesta la passphrase della chiave:
  
 
  $ ssh mith@metawire.org
 
  $ ssh mith@metawire.org
  Enter passphrase for key '/home/mith/.ssh/id_dsa':
+
  Enter passphrase for key '/home/mith/.ssh/id_ecdsa':
  
Se non è possibile effettuare il login con la chiave, controllare i permessi sul file <code>authorized_keys</code>.
+
Se non è possibile effettuare il login con la chiave, controllare i permessi sul file {{ic|authorized_keys}}.
  
Controllate anche i permessi della cartella <code>~/.ssh</code>, 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 <code>~/.ssh</code>:
+
Controllare anche i permessi della cartella {{ic|~/.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 {{ic|~/.ssh}}:
 
  $ chmod go-w ~/.ssh
 
  $ chmod go-w ~/.ssh
  
= Memorizzare le passphrase delle chiavi =
+
==Disabilitare i login con la password==
 +
Impostare le chiavi SSH non basta per garantire maggiore sicurezza. Sarà necessario disabilitare i login tramite password:
  
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.
+
{{hc|/etc/ssh/sshd_config|2=<nowiki>
 +
PasswordAuthentication no
 +
ChallengeResponseAuthentication no</nowiki>}}
  
== ssh-agent ==
+
==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 è l'agente predefinito fornito da OpenSSH.
  
Line 77: Line 103:
 
  echo Agent pid 2148;
 
  echo Agent pid 2148;
  
Quando si esegue <code>ssh-agent</code> verranno stampate quali variabili d'ambiente verranno usate... Per usufruire di queste variabili eseguire il comando tramite <code>eval</code>.
+
Quando si esegue {{ic|ssh-agent}} verranno stampate le variabili d'ambiente che si stanno per utilizzare. Per usufruire di queste variabili eseguire il comando tramite {{ic|eval}}.
  
 
  $ eval `ssh-agent`
 
  $ eval `ssh-agent`
 
  Agent pid 2157
 
  Agent pid 2157
  
È possibile aggiungere il seguente comando al proprio <code>.bashrc</code> in modo che venga eseguito ogni volta che si crea una nuova shell:
+
È possibile aggiungere il seguente comando al file {{ic|/etc/profile}} in modo che venga eseguito ogni volta che si apre una nuova sessione:
  
  $ echo 'eval `ssh-agent`' >> ~/.bashrc
+
  $ echo 'eval `ssh-agent`' >> /etc/profile
  
 
Notare le differenti virgolette, alcune sono apici, altre sono virgolette arricciate!
 
Notare le differenti virgolette, alcune sono apici, altre sono virgolette arricciate!
  
Ora che il <code>ssh-agent</code> è in esecuzione, bisognerà istruirlo sull'esistenza di una chiave privata e sulla sua ubicazione.
+
Ora che {{ic|ssh-agent}} è in esecuzione, bisognerà istruirlo sull'esistenza di una chiave privata e relativa ubicazione.
  
  $ ssh-add ~/.ssh/id_dsa
+
  $ ssh-add ~/.ssh/id_ecdsa
  Enter passphrase for /home/user/.ssh/id_dsa:
+
  Enter passphrase for /home/user/.ssh/id_ecdsa:
  Identity added: /home/user/.ssh/id_dsa (/home/user/.ssh/id_dsa)
+
  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.
 
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 <code>ssh-agent</code> deve essere creata per ogni nuova console (shell) che si apre, il che significa che è necessario eseguire <code>ssh-add</code> ogni volta su ogni console. C'è una soluzione a questo inconveniente con un programma, o meglio uno script chiamato [http://www.gentoo.org/proj/en/keychain/index.xml keychain] che è illustrato nella sezione successiva.
+
L'unico aspetto negativo è che una nuova istanza di {{ic|ssh-agent}} deve essere creata per ogni nuova console (shell) aperta, il che significa che è necessario eseguire {{ic|ssh-add}} ogni volta su ogni console. C'è una soluzione a questo inconveniente con un programma, o meglio uno script chiamato [http://www.gentoo.org/proj/en/keychain/index.xml keychain] che è illustrato nella sezione successiva.
  
=== Uso di GnuPG Agent ===
+
====Uso di GnuPG Agent====
 +
L'agente [[GnuPG]], distribuito con il pacchetto {{Pkg|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.
  
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 {{ic|--enable-ssh-support}}. Esempi(non dimenticare di rendere eseguibile il file):
 +
{{hc|/etc/profile.d/gpg-agent.sh|2=<nowiki>
 +
#!/bin/sh
  
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"
  
  # Start the GnuPG agent and enable OpenSSH agent emulation
+
if pgrep -u "${USER}" gpg-agent >/dev/null 2>&1; then
  gnupginf="${HOME}/.gnupg/gpg-agent.info"
+
    eval `cat $gnupginf`
 
+
    eval `cut -d= -f1 $gnupginf | xargs echo export`
  if ( pgrep -u "${USER}" gpg-agent ); then
+
else
      eval `cat $gnupginf`
+
    eval `gpg-agent --enable-ssh-support --daemon`
      eval `cut -d= -f1 $gnupginf | xargs echo export`
+
fi
  else
+
</nowiki>}}
      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:  
+
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 {{ic|~/.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 {{ic|~/.gnupg/gpg-agent.conf}}. L'esempio seguente mantiene la cache delle chiavi di gpg-agent per 3 ore:  
  
 
   # Cache settings
 
   # Cache settings
Line 120: Line 148:
 
   default-cache-ttl-ssh 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...:
+
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
 
   # Environment file
Line 133: Line 161:
 
   pinentry-program /usr/bin/pinentry-gtk-2
 
   pinentry-program /usr/bin/pinentry-gtk-2
  
=== Utilizzo di portachiavi ===
+
====Utilizzo di portachiavi====
[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.
+
[http://www.funtoo.org/en/security/keychain/intro/ 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 (Italiano)|Installare]] il pacchetto {{Pkg|keychain}} dai [[Official Repositories (Italiano)|repository ufficiali]].
+
 
# pacman -S keychain
+
Aggiungere il seguente comando nel proprio {{ic|.bashrc}},{{ic|.bash_profile}}, oppure creare il file {{ic|/etc/profile.d/keychain.sh}} come utente root e renderlo eseguibile (esempio {{ic|chmod 755 keychain.sh}}).
  
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`
  
Oppure
+
Aggiungendo l'opzione {{ic|-q}} o {{ic|--quiet}} al comando keychain non mostrerà l'output del comando nelle nuove sessioni. Notare anche che l'opzione {{ic|--agents}} non è strettamente necessaria, perché keychain costruirà la lista automaticamente basandosi sull'esistenza di {{Pkg|ssh-agent}} o {{Pkg|gpg-agent}} nel sistema. Se si desidera una maggiore sicurezza sostituire -Q con --clear, anche se non sarà molto conveniente.
 
+
/usr/bin/keychain -Q -q --nogui ~/.ssh/id_dsa
+
<nowiki>[[ -f $HOME/.keychain/$HOSTNAME-sh ]]</nowiki> && source $HOME/.keychain/$HOSTNAME-sh
+
 
+
{{Tip| Se si desidera una maggiore sicurezza sostituire -Q con --clear ma sarà meno conveniente.}}
+
  
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.
+
Se necessario, sostituire {{ic|~/.ssh/id_ecdsa}} con il percorso della propria chiave privata.  Per coloro che usano una shell non compatibile con bash, vedere {{ic|keychain --help}} o {{ic|man keychain}} 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.
 
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.
  
=== Utilizzo di ssh-agent e ssh-x11-askpass ===
+
'''Metodo alternativo'''
 +
{{hc|/etc/profile.d/keychain.sh|2=<nowiki>
 +
/usr/bin/keychain -Q -q --nogui ~/.ssh/id_ecdsa
 +
[[ -f $HOME/.keychain/$HOSTNAME-sh ]] && source $HOME/.keychain/$HOSTNAME-sh
 +
</nowiki>}}
  
È necessario avviare ssh-agent ogni volta che si avvia una nuova sessione di X. Ssh-agent sarà chiuso quando termina la sessione X.
+
====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 <code>x11-ssh-askpass</code>, che chiederà la password ogni volta che si apre un nuova sessione di X:
+
Installare una variante di x11-ssh-askpass, che chiederà la password ogni volta che si apre un nuova sessione di X. Sarà possibile scegliere tra l'originale {{Pkg|x11-ssh-askpass}} {{Pkg|ksshaskpass}} (che utilizza {{Pkg|kdelibs}}) oppure {{Pkg|openssh-askpass}} (che utilizza le qt) tutti reperibili dai [[Official Repositories (Italiano)|repository ufficiali]].
  
# pacman -S x11-ssh-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.
  
Aggiungere le seguenti righe a <code>~/.xsession</code>:
+
===GNOME Keyring===
 +
Se si utilizza il desktop [[GNOME (Italiano)|GNOME]], lo strumento [http://live.gnome.org/GnomeKeyring GNOME Keyring] può essere usato come agente SSH. La configurazione è semplice, per prima cosa [[Pacman (Italiano)|installare]] {{Pkg|gnome-keyring}}.
  
eval `/usr/bin/ssh-agent`
+
Successivamente si devono aggiungere le proprie chiavi SSH, ed inserire la parola chiave.
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 ==
+
$ ssh-add ~/.ssh/id_ecdsa
 +
Enter passphrase for /home/mith/.ssh/id_ecdsa:
  
If you use the [[GNOME]] desktop, the [http://live.gnome.org/GnomeKeyring GNOME Keyring] tool can be used as an SSH agent. Setup is simple, first install it:
+
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.
  
# pacman -S gnome-keyring
+
==Risoluzione di problemi==
 +
Se sembra che il server SSH stia ignorando le vostre chiavi, assicuratevi che i permessi siano corretti sui file interessati.
  
Next you need to add your SSH keys, and enter the passphrase.
+
Per la macchina locale:
  
  $ ssh-add ~/.ssh/id_dsa
+
  $ chmod 700 ~/
  Enter passphrase for /home/mith/.ssh/id_dsa:
+
$ chmod 700 ~/.ssh
 +
  $ chmod 600 ~/.ssh/id_ecdsa
  
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!
+
Per la macchina remota:
  
= PuTTY =
+
$ chmod 700 ~/
 
+
$ chmod 700 ~/.ssh
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 [http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html here]. The procedure is then as follows:
+
$ chmod 600 ~/.ssh/authorized_keys
  
# 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)
+
Se anche questo non aiuta, lanciare il demone {{ic|sshd}} in modalità debug e monitorare l'output durante la connessione:
# Add the public key to the ''~/.ssh/authorized_keys'' file
+
# Move the private key to the Windows machine
+
# Load the private key with PuTTYgen and click ''Save private key''. This will convert the key so that PuTTY can use it.
+
# 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.
+
# /usr/sbin/sshd -d
  
= Useful Links / Information =
+
==Altre risorse==
* [http://www.puddingonline.com/~dave/publications/SSH-with-Keys-HOWTO/document/html-one-page/SSH-with-Keys-HOWTO.html SSH with Keys HOWTO]
+
* [http://www.arches.uga.edu/~pkeck/ssh/ HOWTO: impostare le chiavi SSH (in Inglese)]
* [http://www.arches.uga.edu/~pkeck/ssh/ HOWTO: set up ssh keys]
+
* [http://www-106.ibm.com/developerworks/linux/library/l-keyc.html OpenSSH gestione delle chiavi, Parte 1]
<!-- Not Found + [http://particle.phys.uvic.ca/doc_sshkey.html ] -->
+
* [http://www-106.ibm.com/developerworks/linux/library/l-keyc2/ OpenSSH gestione delle chiavi, Parte 2]
* [http://www-106.ibm.com/developerworks/linux/library/l-keyc.html OpenSSH key management, Part 1]
+
* [http://www-106.ibm.com/developerworks/library/l-keyc3/ OpenSSH gestione delle chiavi, Parte 3]
* [http://www-106.ibm.com/developerworks/linux/library/l-keyc2/ OpenSSH key management, Part 2]
+
* [http://kimmo.suominen.com/docs/ssh/ Introduzione a SSH (in Inglese)]
* [http://www-106.ibm.com/developerworks/library/l-keyc3/ OpenSSH key management, Part 3]
+
* Pagina di Manuale: [http://www.openbsd.org/cgi-bin/man.cgi?query=ssh-keygen&apropos=0&sektion=0&manpath=OpenBSD+Current&arch=i386&format=html ssh-keygen(1)]
* [http://kimmo.suominen.com/docs/ssh/ Getting started with SSH]
+
* [http://openssh.org/txt/release-5.7 OpenSSH 5.7 Note di rilascio]
* Manual Pages: [http://www.openbsd.org/cgi-bin/man.cgi?query=ssh-keygen&apropos=0&sektion=0&manpath=OpenBSD+Current&arch=i386&format=html ssh-keygen(1)]
+
* [http://blog.eukhost.com/2006/11/24/sharing-ssh-keys-on-2-linux-servers-to-login-without-authentication/ Sharing SSH keys on 2 linux servers]
+
* [http://www.andremolnar.com/how_to_set_up_ssh_keys_with_putty_and_not_get_server_refused_our_key How to set up SSH keys: Frustration with "Server refused our key" [PuTTY]]
+
* [http://blog.webhosting.uk.com/2007/04/01/securing-your-secure-shell-ssh-service/ Securing your secure shell (SSH) service]
+

Revision as of 13:58, 15 June 2012

Tango-view-refresh-red.pngThis article or section is out of date.Tango-view-refresh-red.png

Reason: Questa pagina è in fase di revisione e potrebbe non essere aggiornata. Seguite per ora le istruzioni della versione inglese. (Discuss in Talk:ArchWiki Translation Team (Italiano)#Pagine Marcate come "out of date" e "Traslateme")

Le chiavi SSH sono una implementazione della crittografia a chiavi pubbliche. Esse risolvono il problema degli attacchi di tipo brute-force sulle password rendendoli impraticabili.In aggiunta, usando le chiavi SSH, 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 la passphrase venga usata per criptare la chiave privata e che debba essere inserita per utilizzare la chiave stessa.

Generare la chiavi SSH

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

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

$ ssh-keygen -b 521 -t ecdsa -C"$(id -un)@$(hostname)-$(date --rfc-3339=date)"
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 (-b 521) ECDSA pubblica/privata (-t ecdsa) contenente un commento con alcune informazioni (-C"$(id -un)"@$(hostname)-$(date --rfc-3339=date)) tramite il comando ssh-keygen.

Nota: Queste chiavi verranno usate solo per l'autenticazione, la scelta di chiavi più grandi non determinerà un maggiore carico per la CPU nel trasferimento dei dati via SSH.

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, vedere OpenSSH 5.7 Note di rilascio. Le chiavi ECDSA potrebbero non essere compatibili con sistemi che utilizzano versioni 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 -t rsa oppure -t dsa e non dimenticare di incrementare la dimensione delle chiavi; eseguire ssh-keygen senza l'opzione -b solitamente fornirà comunque chiavi di dimensioni ragionevoli.

Copiare la chiave pubblica al server remoto

Ora che sono state generate le chiavi, bisogna copiarle la chiave pubblica (*.pub) sul server remoto. (La chiave privata viene mantenuta sul pc da cui verrà effettuata la connessione.)

Metodo semplice

Nota: Se si utilizza un Ternimal su un Mac, sarà necessario installare ssh-copy-id prima di procedere.

Se il nome della chiave è id_rsa.pub basterà semplicemente invocare il comando

$ ssh-copy-id tuo-server.org

oppure se si usa un nome utente differente dal proprio

$ ssh-copy-id nome-utente-per-accedere@tuo-server.org

Se il nome della chiave non è quello standard si otterrà il seguente errore: "/usr/bin/ssh-copy-id: ERROR: No identities found". In questo caso sarà necessario specificare esplicitamente il percorso della chiave:

$ ssh-copy-id -i ~/.ssh/id_ecdsa.pub nome-utente-per-accedere@tuo-server.org

Se necessario, è possibile specificare la porta nella dichiarazione dell'host:

$ ssh-copy-id -i ~/.ssh/id_rsa.pub '-p 221 nomeutente@host'

Metodo tradizionale

Per impostazione predefinita di OpenSSH, la chiave pubblica deve essere concatenata in ~/.ssh/authorized_keys.

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

Questo comando copia la chiave pubblica (id_dsa.pub) sul 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_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 authorized_keys.

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 authorized_keys.

Controllare 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

Disabilitare i login con la password

Impostare le chiavi SSH non basta per garantire maggiore sicurezza. Sarà necessario disabilitare i login tramite password:

/etc/ssh/sshd_config
PasswordAuthentication no
ChallengeResponseAuthentication no

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 ssh-agent verranno stampate le variabili d'ambiente che si stanno per utilizzare. Per usufruire di queste variabili eseguire il comando tramite eval.

$ eval `ssh-agent`
Agent pid 2157

È possibile aggiungere il seguente comando al file /etc/profile 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 ssh-agent è 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 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. Esempi(non dimenticare di rendere eseguibile il file):

/etc/profile.d/gpg-agent.sh
#!/bin/sh

# Start the GnuPG agent and enable OpenSSH agent emulation
gnupginf="${HOME}/.gnupg/gpg-agent.info"

if pgrep -u "${USER}" gpg-agent >/dev/null 2>&1; 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 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 il pacchetto keychain dai repository ufficiali.

Aggiungere il seguente comando nel proprio .bashrc,.bash_profile, oppure creare il file /etc/profile.d/keychain.sh come utente root e renderlo eseguibile (esempio chmod 755 keychain.sh).

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

Aggiungendo l'opzione -q o --quiet al comando keychain non mostrerà l'output del comando nelle nuove sessioni. Notare anche che l'opzione --agents non è strettamente necessaria, perché keychain costruirà la lista automaticamente basandosi sull'esistenza di ssh-agent o gpg-agent nel sistema. Se si desidera una maggiore sicurezza sostituire -Q con --clear, anche se non sarà molto conveniente.

Se necessario, sostituire ~/.ssh/id_ecdsa con il percorso della propria chiave privata. Per coloro che usano una shell non compatibile con bash, vedere keychain --help o man keychain 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.

Metodo alternativo

/etc/profile.d/keychain.sh
/usr/bin/keychain -Q -q --nogui ~/.ssh/id_ecdsa
[[ -f $HOME/.keychain/$HOSTNAME-sh ]] && source $HOME/.keychain/$HOSTNAME-sh

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. Sarà possibile scegliere tra l'originale x11-ssh-askpass ksshaskpass (che utilizza kdelibs) oppure openssh-askpass (che utilizza le qt) tutti reperibili dai repository ufficiali.

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 gnome-keyring.

Successivamente 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 di problemi

Se sembra che il server SSH stia ignorando le vostre chiavi, assicuratevi che i permessi siano corretti sui file interessati.

Per la macchina locale:

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

Per la macchina remota:

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

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

# /usr/sbin/sshd -d

Altre risorse