OpenSSH Public Key Authentifizierung - Teil 1

Autoren: Michael Gisbers und Christian Hesse

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, siehe 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 allen 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.