Tipp: OpenSSH mit Public Keys

OpenSSH Public Key Authentifizierung

Nachdem sich der erste Teil der Reihe mit den grundlegenden Funktionen der Secure SHell befasst hat, gehen wir nun einen Schritt weiter. Thema dieses Artikels ist die Anmeldung ohne Passwort per Public Key Authentifizierung.

Öffentlicher und privater Schlüssel

Die Idee eines Schlüssels ist hinreichend bekannt: Er gewährt Zugang zu einem System. Ein symmetrischer Schlüssel — also ein Schlüssel lediglich zum Verschlüsseln und Entschlüsseln — genügt unseren Ansprüchen an dieser Stelle allerdings nicht.

Stattdessen verwenden wir ein Schlüsselpaar (Key Pair), bestehend
aus öffentlichem und privatem Schlüssel. Die beiden Teile des Schlüsselpaares sind fest miteinander verbunden und ergänzen sich
komplementär.

Der öffentliche Schlüssel ist — wie der Name schon sagt — kein
Geheimnis, muss also nicht vor fremdem Zugriff eigens geschützt
werden. Er wird auf dem entfernten Rechner hinterlegt.

Der private Schlüssel hingegen ist hingegen sehr wohl zu schützen! Er
darf den lokalen Rechner nicht verlassen und keiner fremden Person in die Hände fallen — andernfalls hat diese Zugriff auf entfernte
Rechner, auf denen der öffentliche Schlüssel liegt.

Bei der Authentifizierung am entfernten Rechner wird zunächst auf dem lokalen Rechner eine Zeichenfolge mit dem privaten Schlüssel
verschlüsselt und an den entfernten Rechner übertragen. Dieser kann
mit dem öffentlichen Schlüssel die Nachricht wieder entschlüsseln, die Authentizität feststellen und daraufhin den Zugriff gewähren.

Durch die gegenseitige Abhängigkeit ist der eine Teil des Schlüsselpaares wertlos, sollte der jeweils andere verlorengehen. Es
ist nicht möglich, den einen aus dem anderen Schlüssel neu zu
generieren — das wäre ja auch fatal für die Sicherheit.

Schlüsselpaar generieren

Zum Generieren einen Schlüsselpaares bedienen wir uns des Kommandos ssh-keygen. Es gehört zum Paket OpenSSH und sollte daher auf jedem aktuellen Rechner zu finden sein, der auch ssh zur Verfügung stellt. ssh-keygen wird ohne Parameter aufgerufen und erstellt standardmäßig einen RSA-Schlüssel
(http://de.wikipedia.org/wiki/RSA-Kryptosystem) mit 2048 Bit, was dem aktuellen Stand der Sicherheitsanforderungen entspricht.

user@linux ~ $ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Created directory '/home/user/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
The key fingerprint is:
20:04:09:a8:88:ba:bb:bd:27:6d:fd:56:0f:e7:f3:a6 user@linux
The key's randomart image is:
+--[ RSA 2048]----+
|o..o.            |
|. ..             |
|+   . .          |
|+    . .         |
|.       S        |
|.         o .    |
| . . .   . =     |
|... + . .   + .  |
|ooo=   o.   E=.  |
+-----------------+

Die interaktive Eingabe einer Passphrase ist optional, erhöht aber
die Sicherheit: Ist eine Passphrase gesetzt, muss ein potentieller
Angreifer den privaten Schlüssel und die Passphrase erbeuten, um
Zugang zu entfernten Rechnern zu erlangen.

ssh-keygen legt zwei Dateien im versteckten Verzeichnis .ssh im
Heimatverzeichnis des Benutzers ab:

id_rsa
der private Schlüssel; an dieser Stelle geben wir uns mit der Existenz zufrieden und gehen nicht weiter darauf ein.
id_rsa.pub
der öffentliche Schlüssel mit alle wichtigen Informationen (in einer Zeile!):

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3opFtZpLWAJc0t+Epkj80FVKs0wgENNH
LfRxFsJrXVVMEl8mAMCMQogX71h8hkCK7jjVXqc/ZNDoj531pefIUv99q1/jvylsQItHC+V
iax2gZNe4GSU6lvWPPKVHYcHq0rR+isbRk7ZmyCx5q3Vmja9fJK8zwsLRA8CieQ0sFG/uqm
9GrcGE5UC07Q4G6H06Vuo2eWMrvXb5crAI/LKCKcFhQr5mg1UG9otz+DYWwmFL2oB3xaCoa
ONaROTugAziToO2ZwlaxVKWD3802zjRYn+LlSoAcRA3PLx9wTXnXN+SWSbYx8J41IhAI5t1
M/AOOtpDPTj8G1xzlO0v3zS5/ user@linux

Öffentlichen Schlüssel eintragen

Der öffentliche Schlüssel muss nun auf den entfernten Rechner übertragen werden. Haben wir keinen physikalischen Zugriff, hilft
natürlich auch eine SSH-Verbindung — authentifiziert per Passwort. Der öffentliche Schlüssel muss in die Datei authorized_keys, ebenfalls im Verzeichnis .ssh im Heimatverzeichnis des Benutzers, eingetragen werden. Dabei ist darauf zu achten, dass der Schlüssel in einer Zeile steht, also keine Zeilenumbrüche enthalten darf:

user@remote ~ $ cat "ssh-rsa AAAAB3NzaC[...]zlO0v3zS5/ user@linux" >> .ssh/authorized_keys

Da Administratoren potentiell faul sind, können Sie alternativ auch das Kommando ssh-copy-id vom lokalen Rechner nutzen, um den öffentlichen Schlüssel auf dem entfernten Rechner einzutragen:

user@linux ~ $ ssh-copy-id user@remote
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
Password:

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'user@remote'"
and check to make sure that only the key(s) you wanted were added.

Ist der öffentliche Schlüssel erfolgreich auf dem entfernten Rechner
eingetragen, kann sich der Benutzer ohne Passwort anmelden:

user@linux ~ $ ssh user@remote
user@remote ~ $ exit

Der öffentliche Schlüssel ermöglicht den Zugriff nur für das Konto, zu
dem er hinterlegt ist. Falls der Zugriff auf verschiedene Konten mit demselben privaten Schlüssel gewünscht ist, müssen wir für jeden
Benutzer den oben genannten Kopierschritt durchführen.

Im nächsten Artikel dieser Reihe schauen wir uns die weiteren
Möglichkeiten der Datei authorized_keys an und erfahren, wie wir das ständige Eintippen des Kennwortes für die privaten Schlüssel auf
sichere Art umgehen.


Dieser Text ist im Rahmen des Tipp des Monats von Michael Gisbers und Christian Hesse auf der Website des LPI Central Europe unterstützt von der Open Source Press veröffentlicht worden.