öffnen Tags

öffnen Kategorien

Vom WebReader vorlesen lassen

SSH-Zugang mit Keys absichern

19. Aug 2009, 21:10

Um entfernte Rechner zu administrieren oder einfach auf ihnen zu arbeiten nutzen die meisten wohl OpenSSH (im folgenden einfach nur noch SSH). Dank verschlüsselter Datenübertragung, inklusive Anmeldung, ist es eine sichere telnet-Alternative!

Dass die Login-Daten (Name und Passwort) verschlüsselt übertragen werden, schließt lediglich ein mitschneiden der sensiblen Informationen aus, Angreifer haben aber weiter die (wenn auch geringe) Chance das Passwort zu einem Account zu erraten.
Diese Möglichkeit ist bei sicherheitskritischen Servern fatal, man möchte das Risiko eines Eindringlings auf Firewall oder Mailserver gern eliminieren.

Hier bietet sich an die Authentifizierung per Keys zu erledigen und Passwörter abzuschalten. Bei dieses sogenannte Public-Key-Verfahren erstellen sich die User ein Schlüsselpaar aus privaten (private key) und öffentlichen (public key) Schlüssel. Der private oder auch geheime Schlüssel wird auf dem eigenen Rechner gelagert, der öffentliche Schlüssel wird auf die Server verteilt. Möchte man sich nun auf einem Server anmelden, auf dem man seinen öffentlichen Schlüssel hinterlegt hat, kann der Client in einem Challenge-Response-Dialog seine Identität nachweisen. Hierbei sendet der Server einen zufällig generierten Wert, die Challenge, den der Client mit dem privaten Schlüssel verschlüsselt und zurück schickt. Kann der Server diesen verschlüsselten Text nun mit dem public Key entschlüsseln kann, ist der Client authentifiziert.

Ein solchen Schlüsselpaar erzeug man sich wie folgt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
esmz-designz@abakus ~ $ ssh-keygen -t rsa -b 4096
Generating public/private rsa key pair.
Enter file in which to save the key (/home/esmz-designz/.ssh/id_rsa):
Created directory '/home/esmz-designz/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/esmz-designz/.ssh/id_rsa.
Your public key has been saved in /home/esmz-designz/.ssh/id_rsa.pub.
The key fingerprint is:
16:59:cb:9f:55:b1:39:ee:b3:72:14:19:13:5c:60:4d esmz-designz@abakus
The key's randomart image is:
+--[ RSA 4096]----+
| . +*E|
| + . . =+|
| o o .++|
| . . o.o.|
| S o ..|
| . .. |
| .o |
| . .o|
| o. |
+-----------------+

Damit hab ich einen Schlüssel mit einer Größe von 4096 Bits erzeugt (-b), Standard wäre 2048, in solchen Sachen bin ich aber ziemlich paranoid. Statt RSA- ist es auch möglich DSA-Schlüssel zu nutzen, diese sind dann zwingend 1024 Bit groß und werden mit -t dsa im Befehl erstellt.
Den vorgeschlagenen Namen id_rsa kann man mit Return bestätigen. Möchte man verschiedene Schlüssel erstellen gibt man hier einen alternativen Namen an. Ist das gewählte File vorhanden, muss man eine Sicherheitsfrage bejaen bevor der vorhandene Schlüssel überschrieben wird.
Von der Benutzung einer leeren Passphrase kann ich nur abraten. Es ist wirklich sehr komfortabel, wenn man ohne Passwort Zugriff auf einen Server erhält, fällt die Datei mit dem privaten Schlüssel dann aber in fremde Hände, können diese den Response-Chiffre ohne weiteres erzeugen und erhalten sofortigen Zugriff auf die zu schützenden Systeme!

Nun existieren zwei neue Dateien in ~/.ssh/, zum einen der öffentliche Schlüssel in id_rsa.pub und der private Schlüssel in id_rsa.
Um den public Key nun auf die Zielrechner zu verteilen bietet sich ssh-copy-id an:

1
2
3
4
5
6
7
8
9
10
11
esmz-designz@abakus ~ $ ssh-copy-id -i /home/esmz-designz/.ssh/id_rsa.pub esmz-designz@192.168.0.111
The authenticity of host '192.168.0.111 (192.168.0.111)' can't be established.
RSA key fingerprint is 34:cd:e7:95:48:75:d4:16:86:84:19:f0:b4:d3:2c:ad.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.0.111' (RSA) to the list of known hosts.
esmz-designz@192.168.0.111's password:
Now try logging into the machine, with "ssh 'esmz-designz@192.168.0.111'", and check in:

.ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

Die ersten Zeilen sind für uns uninteressant, ich kannte den RSA-Key des Servers (für den Test nur eine Virtual Box) noch nicht um ihn eindeutig identifizieren zu können. Die Zeilen zwei bis fünf sind also reine Bestätigung, dass ich mich zu diesem Server verbinden möchte. In Zeile sechs gebe ich wohl zum letztem Mal das Passwort zu dem Account auf dem Server ein, in Zukunft muss ich nur noch den Key entsperren. Mit den letzten Zeilen wird bestätigt was gemacht wird, der public Key wird in die authorized_keys des Accounts auf dem Server geschrieben (ihr könntet dies auch händisch selbst erledigen indem ihr den Inhalt des public Key-Files in eine neue Zeile der Datei ~/.ssh/authorized_keys im Home des Accounts auf dem Server schreibt). Ihr müsst unbedingt darauf achten, dass ihr den öffentlichen Schlüssel verteilt! Der private Schlüssel sollte wirklich nur bei euch auf dem Rechner existieren.

Nun kann ich mich zum Server verbinden und muss lediglich die Passphrase des Keys eingeben:

1
2
3
4
5
esmz-designz@abakus ~ $ ssh esmz-designz@192.168.0.111
Enter passphrase for key '/home/esmz-designz/.ssh/id_rsa':
Linux siduxbox 2.6.30-4.slh.1-sidux-amd64 #1 SMP PREEMPT Sun Aug 2 09:58:18 UTC 2009 x86_64
Last login: Wed Aug 19 12:12:18 2009 from 192.168.0.55
esmz-designz@siduxbox ~ $

Funktioniert doch super, oder? Nun können wir uns dran machen den Zugang per Passwort abzuschalten. Dies ist nicht schwer, wir müssen in der Konfiguration des SSH-Deamons (/etc/ssh/sshd_config) nur folgende Optionen setzen:

1
2
PasswordAuthentication no
UsePAM no

und den Deamon neu starten:

1
/etc/init.d/ssh restart

Damit kommt nun nur noch der an den Server, der den private Key besitzt und das Passwort zum Schlüssel kennt. Es ist natürlich möglich andere Accounts auf dem Server anzulegen und diese auch per Key zugänglich zu machen.

Tags: Kryptographie Linux Software SSH Unix

Kategorien: Betriebssystem Linux Software Unix

© 2009-2018 by Martin Scharm