SSH-Authentifizierung mit Schlüsselpaaren: Unterschied zwischen den Versionen

Aus wiki.archlinux.de
(Änderung 13646 von 77.117.246.218 (Diskussion) rückgängig gemacht.)
K (Warum einen unsichereren DSA-1024-Schlüssel, wenn man auch einen maximal sicheren RSA-4096-Schlüssel haben kann?)
Zeile 12: Zeile 12:
Danach kann das Schlüsselpaar mit folgendem Befehl erzeugt werden:
Danach kann das Schlüsselpaar mit folgendem Befehl erzeugt werden:


  $ ssh-keygen -b 1024 -t dsa
  $ ssh-keygen -b 4096


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.
Dabei wird ein 4096 Bit langer (<code>-b 4096</code>) Schlüssel erzeugt. 4096 ist die maximale Länge eines Schlüssels.
 
'''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:
Ein ähnlicher Output wie dieser sollte folgen:


  Generating public/private dsa key pair.
  Generating public/private rsa key pair.
  Enter file in which to save the key (/home/mith/.ssh/id_dsa):
  Enter file in which to save the key (/home/mith/.ssh/id_rsa):
  Enter passphrase (empty for no passphrase):
  Enter passphrase (empty for no passphrase):
  Enter same passphrase again:
  Enter same passphrase again:
  Your identification has been saved in /home/mith/.ssh/id_dsa.
  Your identification has been saved in /home/mith/.ssh/id_rsa.
  Your public key has been saved in /home/mith/.ssh/id_dsa.pub.
  Your public key has been saved in /home/mith/.ssh/id_rsa.pub.
  The key fingerprint is:
  The key fingerprint is:
  x6:68:xx:93:98:8x:87:95:7x:2x:4x:x9:81:xx:56:94 mith@middleearth
  x6:68:xx:93:98:8x:87:95:7x:2x:4x:x9:81:xx:56:94 mith@middleearth
Zeile 35: Zeile 33:
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.
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:
  $ scp ~/.ssh/id_rsa.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''.
Dies kopiert den öffentlichen Schlüssel mit dem Namen ''id_rsa.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:
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:
Zeile 44: Zeile 42:
  user@archlinux.de's password:
  user@archlinux.de's password:
  $ mkdir ~/.ssh
  $ mkdir ~/.ssh
  $ cat ~/id_dsa.pub >> ~/.ssh/authorized_keys
  $ cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
  $ rm ~/id_dsa.pub
  $ rm ~/id_rsa.pub
  $ chmod 600 ~/.ssh/authorized_keys
  $ chmod 600 ~/.ssh/authorized_keys


Zeile 53: Zeile 51:


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


Wenn das Login scheitert, sollte man zuerst überprüfen, ob die Rechte für ''authorized_keys'' richtig gesetzt wurden.
Wenn das Login scheitert, sollte man zuerst überprüfen, ob die Rechte für ''authorized_keys'' richtig gesetzt wurden.
Zeile 86: Zeile 84:
Nun, da der SSH-Agent läuft, muss man ihm mitteilen, dass man einen Privaten Schlüssel besitzt und wo dieser sich befindet.
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
  $ ssh-add ~/.ssh/id_rsa
  Enter passphrase for /home/user/.ssh/id_dsa:
  Enter passphrase for /home/user/.ssh/id_rsa:
  Identity added: /home/user/.ssh/id_dsa (/home/user/.ssh/id_dsa)
  Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)


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.
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.
Zeile 142: Zeile 140:
Oder
Oder


  /usr/bin/keychain -Q -q --nogui ~/.ssh/id_dsa
  /usr/bin/keychain -Q -q --nogui ~/.ssh/id_rsa
  <nowiki>[[ -f $HOME/.keychain/$HOSTNAME-sh ]]</nowiki> && source $HOME/.keychain/$HOSTNAME-sh
  <nowiki>[[ -f $HOME/.keychain/$HOSTNAME-sh ]]</nowiki> && source $HOME/.keychain/$HOSTNAME-sh


Oder man fügt
Oder man fügt
  eval `keychain --eval --agents ssh id_dsa`
  eval `keychain --eval --agents ssh id_rsa`
der ''.bashrc'' oder ''.bash_profile'' hinzu.
der ''.bashrc'' oder ''.bash_profile'' hinzu.


Für mehr Sicherheit kann das '''-Q''' durch ein unpraktischeres '''--clear''' ersetzt werden.
Für mehr Sicherheit kann das '''-Q''' durch ein unpraktischeres '''--clear''' ersetzt werden.
Wenn nötig muss die Datei ''~/.ssh/id_dsa'' durch ''~/.ssh/id_rsa'' ersetzt werden.


Nach einem Neustart der Shell sollte Keychain gestartet werden und sofern es der erste Start der Sitzung ist, nach einem Passwort fragen.
Nach einem Neustart der Shell sollte Keychain gestartet werden und sofern es der erste Start der Sitzung ist, nach einem Passwort fragen.

Version vom 13. Dezember 2012, 21:01 Uhr

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 4096

Dabei wird ein 4096 Bit langer (-b 4096) Schlüssel erzeugt. 4096 ist die maximale Länge eines Schlüssels.

Ein ähnlicher Output wie dieser sollte folgen:

Generating public/private rsa key pair.
Enter file in which to save the key (/home/mith/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/mith/.ssh/id_rsa.
Your public key has been saved in /home/mith/.ssh/id_rsa.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 Standardeingabe 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_rsa.pub user@archlinux.de:

Dies kopiert den öffentlichen Schlüssel mit dem Namen id_rsa.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_rsa.pub >> ~/.ssh/authorized_keys
$ rm ~/id_rsa.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_rsa':

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_rsa
Enter passphrase for /home/user/.ssh/id_rsa:
Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)

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.

GnuPG-Agent nutzen

Der GnuPG-Agent befindet sich im Paket gnupg2 und bietet eine SSH-Agent-Emulation. Wenn man diesen benutzen will, dann wird man ihn wahrscheinlich für alle seine Schlüsselpaare verwenden wollen. Außerdem könnte der PIN-Eingabedialog und dessen Passwort-Manager, welche sich von Keychain unterscheiden, von Interesse sein.

Um den GPG-Agenten für SSH-Schlüssel zu benutzen, muss dieser mit der --enable-ssh-support Option gestartet werden. Beispiel (das Script muss natürlich ausführbar sein):

#!/bin/sh

envfile="${HOME}/.gnupg/gpg-agent.env"
if test -f "$envfile" && kill -0 $(grep GPG_AGENT_INFO "$envfile" | cut -d: -f 2) 2>/dev/null; then
    eval "$(cat "$envfile")"
else
    eval "$(gpg-agent --enable-ssh-support --daemon --write-env-file "$envfile")"
fi

Wenn der GPG-Agent läuft, kann mit ssh-add, wie im vorherigen Beispiel, der gewünschte Schlüssel hinzugefügt werden. Die Liste der hinzugefügten Schlüssel wird unter ~/.gnupg/sshcontrol gespeichert. Sobald ein hinzugefügter Schlüssel benötigt wird, erscheint eine PIN-Eingabeaufforderung. Der PIN kann für einen selbst gewählten Zeitraum zwischengespeichert werden. Für eine Speicherdauer von drei Stunden editiert man die Datei ~/.gnupg/gpg-agent.conf wie folgt:

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

Andere nützliche Einstellungen für diese Datei, wie das benutzte Toolkit (GTK, QT oder ncurses), Keyboard Grabbing und anderes:

 # 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

Keychain benutzen

Keychain kümmert sich um einen oder mehrere Private Schlüssel. Wenn Keychain gestartet wird, fragt es das Passwort ab und speichert dieses zwischen, so dass es pro Sitzung nur einmal eingegeben werden muss.

Keychain aus [extra] installieren:

# pacman -S keychain

Nun muss die folgende Datei /etc/profile.d/keychain.sh erstellt und ausführbar gemacht werden:

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

Oder

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

Oder man fügt

eval `keychain --eval --agents ssh id_rsa`

der .bashrc oder .bash_profile hinzu.

Für mehr Sicherheit kann das -Q durch ein unpraktischeres --clear ersetzt werden.

Nach einem Neustart der Shell sollte Keychain gestartet werden und sofern es der erste Start der Sitzung ist, nach einem Passwort fragen.

SSH-Agent und X11-SSH-Askpass benutzen

Für diese Methode muss der SSH-Agent direkt beim Starten einer neuen XSession mit gestartet werden. Er wird automatisch mit der XSession beendet.

Zuerst installiert man das Paket x11-ssh-askpass. Dieses wird bei jedem Start einer XSession nach dem Passwort fragen:

# pacman -S x11-ssh-askpass

Folgendes muss an den Anfang der ~/.xsession

eval `/usr/bin/ssh-agent`
SSH_ASKPASS=/usr/lib/openssh/x11-ssh-askpass ssh-add < /dev/null
# dann folgt das Ende der Datei mit z.B. "exec dwm"

GNOME-Schlüsselbund

Um den GNOME-Schlüsselbund als SSH-Agenten zu benutzen, besuche den Gnome Schlüsselbund Artikel.

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

Weblinks