SSH-Authentifizierung mit Schlüsselpaaren

Aus wiki.archlinux.de

Was sind SSH-Schlüsselpaare?

Wenn man SSH-Schlüsselpaare (einen öffentlichen und privaten Schlüssel) benutzt, kann man einfach und sicher eine SSH-Verbindung zu einem Server herstellen, ohne ein Passwort für eines der Systeme eingeben zu müssen.

Es ist möglich, diese Schlüssel ohne ein Passwort einzurichten, jedoch ist es sicherer, eines zu benutzen, für den Fall, dass ungewollt ein Dritter an diesen Schlüssel kommt. Deshalb beschreibt diese Anleitung auch, wie man das benutzte Passwort sicher auf seinem System speichern kann.

Ein Schlüsselpaar erzeugen

Wenn OpenSSH noch nicht installiert worden ist, muss dies jetzt nachgeholt werden:

# pacman -S openssh

Danach kann das Schlüsselpaar mit folgendem Befehl erzeugt werden:

$ ssh-keygen -b 1024 -t dsa

Dabei wird ein 1024 Bit langer (-b 1024) Schlüssel des Typs DSA (-t dsa) erzeugt. Stattdessen kann auch ein Schlüsselpaar des Typs RSA erzeugt werden. Dabei genügt die Option -t rsa (ohne -b), da die Standardlänge mit 2048 Bit lang genug sein sollte.

Achtung: Ein DSA-Schlüssel muss exakt 1024 Bit lang sein, wogegen ein RSA-Schlüssel zwischen 768 und 4096 Bit lang sein kann.

Ein ähnlicher Output wie dieser sollte folgen:

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

Wie hier zu sehen ist, wird man zuerst gefragt, wo der Schlüssel gespeichert werden soll (wobei es bei der Standarteingabe belassen werden sollte). Danach kommt die wichtigste Eingabe: das Passwort. Was ein sicheres Passwort ist, kann in diesem Wikipedia-Artikel nachgelesen werden.

Übertragen der Schlüssel zum SSH-Server

Nachdem die benötigten Schlüsselpaare erzeugt wurden, müssen deren öffentlichen Schlüssel zum SSH-Server übertragen werden. Standardmäßig werden diese unter ~/.ssh/authorized_keys gespeichert.

$ scp ~/.ssh/id_dsa.pub user@archlinux.de:

Dies kopiert den öffentlichen Schlüssel mit dem Namen id_dsa.pub in den Home-Ordner des Users user auf dem Server archlinux.de.

Nun muss sich zuerst auf dem SSH-Server eingeloggt und dann die Schlüssel in das richtige Verzeichnis kopiert werden. In unserem Beispiel existieren die Ordner dafür noch nicht und müssen zuerst angelegt werden:

$ ssh user@archlinux.de
user@archlinux.de's password:
$ mkdir ~/.ssh
$ cat ~/id_dsa.pub >> ~/.ssh/authorized_keys
$ rm ~/id_dsa.pub
$ chmod 600 ~/.ssh/authorized_keys

Die letzten beiden Kommandos löschen den öffentlichen Schlüssel vom Server (was nicht unbedingt notwendig ist) und setzen die richtigen Rechte für die authorized_keys-Datei.

Wenn man sich nun vom Server ausloggt und versucht sich wieder einzuloggen, sollte man für das Passwort des Schlüsselpaares gefragt werden:

$ ssh user@archlinux.de
Enter passphrase for key '/home/user/.ssh/id_dsa':

Wenn das Login scheitert, sollte man zuerst überprüfen, ob die Rechte für authorized_keys richtig gesetzt wurden.

Weiterhin könnten die Rechte des Ordners ~/.ssh falsch sein. Dieser sollte keine Schreibberechtigung für 'group' und 'other' haben. Um dies richtig zu stellen, muss folgender Befehl ausgeführt werden:

$ chmod go-w ~/.ssh

Schlüssel-Passwort speichern

Nun da alles so konfiguriert ist, dass ein Schlüssel anstatt eines Passworts zum einloggen auf den SSH-Server verwendet werden kann, wir an dieser Stelle erklärt, wie das Passwort im SSH-Agent oder anderen Passwort-Managern gespeichert werden kann.

SSH-Agent nutzen

Der SSH-Agent ist das Standard Tool für diese Aufgabe. Es wir automatisch mit OpenSSH installiert.

$ 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;

Wird der SSH-Agent ausgeführt, gibt er die benutzten Umgebungsvariablen aus. Um diese Variablen zu verwenden, startet man den Agenten durch das eval Kommando:

$ eval `ssh-agent`
Agent pid 2157

Dies kann der /etc/profile hinzugefügt werden, damit es bei jeder Session gestartet wird:

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

Achtung: Es müssen die richtigen Anführungszeichen benutzt werden, am besten kopiert man das Orginal.

Nun, da der SSH-Agent läuft, muss man ihm mitteilen, dass man einen Privaten Schlüssel besitzt und wo dieser sich befindet.

$ 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)

Nun wird das Passwort abgefragt und auch gleich gespeichert und schon kann man sich ohne Passwort, jedoch mit einem Passwort geschützten Schlüsselpaar, auf seinem SSH-Server anmelden.

Das einzige Problem das bleibt ist, dass für jede neue SSH-Verbindung, die aufgebaut werden soll, auch eine neue SSH-Agent-Instanz gestartet werden muss. Abhilfe dafür kann ein Alias oder das Programm Keychain im nächsten Absatz schaffen.

Using GnuPG Agent

The GnuPG agent, distributed with the Vorlage:Package Official package, has OpenSSH agent emulation. If you use GPG you might consider using its agent to take care of all of your keys. Otherwise you might like the PIN entry dialog it provides and its passphrase management, which is different from keychain.

To start using GPG agent for your SSH keys you should first start the gpg-agent with the Vorlage:Codeline option. Example (don't forget to make the file executable): Vorlage:File

Once gpg-agent is running you can use ssh-add to approve keys, just like you did with plain ssh-agent. The list of approved keys is stored in the Vorlage:Filename file. Once your key is approved you will get a PIN entry dialog every time your passphrase is needed. You can control passphrase caching in the Vorlage:Filename file. The following example would have gpg-agent cache your keys for 3 hours:

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

Other useful settings for this file include the PIN entry program (GTK, QT or ncurses version), keyboard grabbing and so on...:

 # 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

Using keychain

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.

Install keychain from the extra repo:

# pacman -S keychain

Create the following file and make it executable: Vorlage:File

Or

Vorlage:File

Or

Append

eval `keychain --eval --agents ssh id_dsa`

to your Vorlage:Filename or Vorlage:Filename.

Vorlage:Tip

If necessary, replace Vorlage:Filename with Vorlage:Filename. For those using a non-Bash compatible shell, see Vorlage:Codeline or Vorlage:Codeline for details on other shells.

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.

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 Vorlage:Filename:

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. Visit the Gnome Keyring article.

Troubleshooting

Wenn der SSH-Server die benutzten Schlüssel ignoriert, sollte erst einmal richtig gestellt werden, dass die richtigen Rechte vergeben wurden.

Für den Client-Computer:

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

Für den SSH-Server:

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

Wenn das nicht weiterhilft, sollte SSH im Debug-Modus gestartet und der Output beachtet werden:

# /usr/sbin/sshd -d

Nützliche Links und Informationen