Anfängerleitfaden für SSH-Schlüssel: Generieren, Verwenden und Sicher Verwalten

SSH-Schlüssel ermöglichen es Ihnen, sich auf Servern anzumelden, ohne ein wiederverwendbares Passwort über das Netzwerk zu senden. Wenn Sie Linux-Server, Cloud-Instanzen oder Git-Remotes verwalten, ist ein ordnungsgemäß geschützter SSH-Schlüssel in der Regel sicherer und einfacher als die passwortbasierte Anmeldung.

Dieser Anfängerleitfaden zeigt Ihnen, wie Sie ein SSH-Schlüsselpaar generieren, den öffentlichen Schlüssel auf einen Server kopieren, mit dem richtigen privaten Schlüssel verbinden und Ihre Schlüssel verwaltbar halten, wenn Ihre Serverliste wächst.

Verstehen von SSH-Schlüsselpaaren

Die SSH-Schlüsselauthentifizierung basiert auf einem Paar kryptografischer Schlüssel: einem privaten Schlüssel und einem öffentlichen Schlüssel. Diese Schlüssel sind mathematisch miteinander verbunden, aber es ist rechnerisch unmöglich, den privaten Schlüssel aus dem öffentlichen Schlüssel abzuleiten.

Privater Schlüssel: Dieser Schlüssel sollte geheim gehalten und niemals weitergegeben werden. Er befindet sich auf Ihrem lokalen Rechner und dient als Ihre Identität. Wenn Sie eine SSH-Verbindung initiieren, verwendet Ihr Client Ihren privaten Schlüssel, um Ihre Identität nachzuweisen.
Öffentlicher Schlüssel: Dieser Schlüssel kann frei weitergegeben werden. Sie platzieren Ihren öffentlichen Schlüssel auf den entfernten Servern, auf die Sie zugreifen möchten. Wenn Sie versuchen, eine Verbindung herzustellen, verwendet der Server Ihren öffentlichen Schlüssel, um zu überprüfen, ob Sie den entsprechenden privaten Schlüssel besitzen.

Wenn Sie versuchen, eine Verbindung zu einem Server herzustellen, läuft der folgende Prozess ab:

Ihr SSH-Client präsentiert dem Server Ihren öffentlichen Schlüssel.
Der Server überprüft, ob dieser öffentliche Schlüssel autorisiert ist (d. h. in seiner authorized_keys-Datei vorhanden ist).
Wenn autorisiert, sendet der Server eine Herausforderung an Ihren Client.
Ihr Client signiert die Herausforderung mit Ihrem privaten Schlüssel und sendet die Signatur zurück an den Server.
Der Server überprüft die Signatur mit Ihrem öffentlichen Schlüssel. Wenn die Signatur gültig ist, wird die Authentifizierung ohne Passwort gewährt.

Generieren von SSH-Schlüsselpaaren

Das gebräuchlichste Werkzeug zum Generieren von SSH-Schlüsselpaaren ist ssh-keygen. Dieser Befehl ist auf den meisten Linux-, macOS- und Windows-Systemen (über WSL oder Git Bash) verfügbar.

Verwenden von `ssh-keygen`

Um ein neues SSH-Schlüsselpaar zu generieren, öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung und führen Sie den folgenden Befehl aus:

ssh-keygen -t ed25519

Lassen Sie uns diesen Befehl aufschlüsseln:

ssh-keygen: Der Befehl zum Generieren von SSH-Schlüsseln.
-t ed25519: Gibt den Typ des zu erstellenden Schlüssels an. ed25519 ist ein moderner, hochsicherer und schneller Algorithmus der elliptischen Kurven-Kryptographie. Andere gebräuchliche Optionen umfassen rsa (z. B. ssh-keygen -t rsa -b 4096 für einen 4096-Bit-RSA-Schlüssel).

Nach dem Ausführen des Befehls werden Sie mit einigen Fragen aufgefordert:

Geben Sie die Datei ein, in der der Schlüssel gespeichert werden soll (z. B. /home/ihr_benutzer/.ssh/id_ed25519): Drücken Sie die Eingabetaste, um den Standardspeicherort zu akzeptieren. Dadurch werden zwei Dateien in Ihrem .ssh-Verzeichnis erstellt: id_ed25519 (Ihr privater Schlüssel) und id_ed25519.pub (Ihr öffentlicher Schlüssel).
Passphrase eingeben (leer für keine Passphrase): Dies ist ein entscheidender Sicherheitsschritt. Die Eingabe einer Passphrase verschlüsselt Ihren privaten Schlüssel auf der Festplatte. Sollte Ihre private Schlüsseldatei jemals kompromittiert werden, müsste der Angreifer dennoch die Passphrase kennen, um sie zu verwenden. Es wird dringend empfohlen, eine starke Passphrase zu verwenden.
Gleiche Passphrase erneut eingeben: Bestätigen Sie Ihre Passphrase.

Verstehen der Ausgabedateien

Nach der Generierung werden zwei Dateien in Ihrem ~/.ssh/-Verzeichnis (oder dem von Ihnen angegebenen Pfad) erstellt:

id_ed25519 (oder id_rsa): Ihr privater Schlüssel. GEBEN SIE DIESE DATEI NIEMALS WEITER. Beschränken Sie die Berechtigungen auf schreibgeschützt für Ihren Benutzer.
id_ed25519.pub (oder id_rsa.pub): Ihr öffentlicher Schlüssel. Dies ist der Schlüssel, den Sie an Server verteilen.

Sichern Ihres privaten Schlüssels

Es ist wichtig, sicherzustellen, dass Ihr privater Schlüssel die korrekten Dateiberechtigungen hat. Führen Sie unter Linux/macOS Folgendes aus:

chmod 600 ~/.ssh/id_ed25519

Dieser Befehl schränkt Lese- und Schreibberechtigungen auf den Eigentümer der Datei ein und verhindert, dass andere Benutzer auf dem System auf Ihren privaten Schlüssel zugreifen können.

Bereitstellen Ihres öffentlichen Schlüssels auf einem Server

Sobald Sie Ihr SSH-Schlüsselpaar generiert haben, müssen Sie Ihren öffentlichen Schlüssel auf dem/den entfernten Server(n) platzieren, auf die Sie zugreifen möchten.

Verwenden von `ssh-copy-id` (Empfohlen)

ssh-copy-id ist ein Dienstprogramm-Skript, das den Prozess des Kopierens Ihres öffentlichen Schlüssels auf einen entfernten Server vereinfacht. Es hängt Ihren öffentlichen Schlüssel automatisch an die Datei ~/.ssh/authorized_keys auf dem Server an und setzt die korrekten Berechtigungen.

Um ssh-copy-id zu verwenden, führen Sie den folgenden Befehl von Ihrem lokalen Rechner aus:

ssh-copy-id benutzer@entfernter_host

Ersetzen Sie benutzer durch Ihren Benutzernamen auf dem entfernten Server und entfernter_host durch die IP-Adresse oder den Hostnamen des Servers. Sie werden ein letztes Mal nach dem Passwort des benutzers auf dem entfernten_host gefragt, um die Schlüsselübertragung zu autorisieren.

Wenn Sie einen nicht standardmäßigen SSH-Port verwenden (z. B. 2222), können Sie ihn mit der Option -p angeben:

ssh-copy-id -p 2222 benutzer@entfernter_host

Manuelle Bereitstellung (Wenn `ssh-copy-id` nicht verfügbar ist)

Wenn ssh-copy-id nicht verfügbar ist, können Sie Ihren öffentlichen Schlüssel manuell kopieren. Zeigen Sie zuerst den Inhalt Ihres öffentlichen Schlüssels auf Ihrem lokalen Rechner an:

cat ~/.ssh/id_ed25519.pub

Kopieren Sie die gesamte Ausgabe. Stellen Sie dann eine SSH-Verbindung zu Ihrem entfernten Server mit Ihrem Passwort her:

ssh benutzer@entfernter_host

Sobald Sie angemeldet sind, erstellen Sie das .ssh-Verzeichnis, falls es nicht existiert, und erstellen oder hängen Sie dann an die Datei authorized_keys an:

mkdir -p ~/.ssh
chmod 700 ~/.ssh

Fügen Sie nun den Inhalt Ihres öffentlichen Schlüssels in die Datei authorized_keys ein. Sie können dies mit einem Texteditor wie nano oder vim tun:

nano ~/.ssh/authorized_keys

Fügen Sie den kopierten öffentlichen Schlüssel in einer neuen Zeile ein. Speichern und schließen Sie den Editor.

Stellen Sie schließlich sicher, dass die Datei authorized_keys die korrekten Berechtigungen hat:

chmod 600 ~/.ssh/authorized_keys

Nach Abschluss dieser Schritte sollten Sie in der Lage sein, sich ohne Passwort per SSH mit dem Server zu verbinden.

Verbinden mit SSH-Schlüsseln

Sobald sich Ihr öffentlicher Schlüssel auf dem Server befindet, können Sie mit Ihrem privaten Schlüssel eine Verbindung herstellen. Der SSH-Client versucht automatisch, Schlüssel zu verwenden, die in ~/.ssh/ gefunden werden.

ssh benutzer@entfernter_host

Wenn Sie bei der Schlüsselgenerierung eine Passphrase verwendet haben, werden Sie aufgefordert, diese jetzt einzugeben. Wenn Sie keine Passphrase verwendet haben, werden Sie direkt angemeldet.

Angeben eines anderen Schlüssels

Wenn Sie mehrere SSH-Schlüsselpaare haben oder sich Ihr Schlüssel nicht am Standardspeicherort befindet, können Sie mit der Option -i angeben, welcher private Schlüssel verwendet werden soll:

ssh -i /pfad/zu/ihrem/privaten_schluessel benutzer@entfernter_host

Verwalten von SSH-Schlüsseln

Wenn Sie auf mehr Server zugreifen, sammeln Sie mehr SSH-Schlüssel an. Effektives Management ist der Schlüssel zur Aufrechterhaltung von Sicherheit und Komfort.

SSH-Agent

Der SSH-Agent ist ein Hintergrundprogramm, das Ihre privaten Schlüssel im Speicher hält, entschlüsselt mit Ihrer Passphrase. Dies ermöglicht es Ihnen, Ihre Schlüssel für mehrere SSH-Verbindungen zu verwenden, ohne jedes Mal Ihre Passphrase erneut eingeben zu müssen.

Starten des SSH-Agents: Der Agent wird oft automatisch gestartet, wenn Sie sich in Ihrer Desktop-Umgebung anmelden. Wenn nicht, können Sie ihn manuell starten:
```
eval "$(ssh-agent -s)"
```
Hinzufügen von Schlüsseln zum Agenten: Sobald der Agent läuft, fügen Sie Ihren privaten Schlüssel hinzu:
```
ssh-add ~/.ssh/id_ed25519
```
Sie werden nach Ihrer Passphrase gefragt. Danach verwaltet der Agent den Schlüssel und nachfolgende SSH-Verbindungen verwenden ihn automatisch.

SSH-Konfigurationsdatei (`~/.ssh/config`)

Die SSH-Client-Konfigurationsdatei (~/.ssh/config) ermöglicht es Ihnen, Aliase für Hosts zu definieren und Verbindungsparameter anzugeben, einschließlich welcher Schlüssel für einen bestimmten Host verwendet werden soll. Dies ist äußerst nützlich für die Verwaltung mehrerer Server.

Erstellen oder bearbeiten Sie die Datei ~/.ssh/config auf Ihrem lokalen Rechner und fügen Sie Einträge wie diesen hinzu:

# Standardeinstellungen
Host *
  ServerAliveInterval 60

# Server 1: Webserver
Host webserver
  HostName 192.168.1.100
  User webadmin
  Port 2222
  IdentityFile ~/.ssh/webserver_key

# Server 2: Datenbankserver
Host dbserver
  HostName db.example.com
  User dbuser
  IdentityFile ~/.ssh/db_key

Mit dieser Konfiguration können Sie eine Verbindung zum Webserver herstellen mit:

ssh webserver

Und zum Datenbankserver mit:

ssh dbserver

Der SSH-Client verwendet automatisch den korrekten Benutzernamen, Port und die private Schlüsseldatei, wie in der Datei ~/.ssh/config definiert. Vermeiden Sie es, ForwardAgent yes global zu aktivieren; Agent-Weiterleitung ist nützlich für einige Jump-Host-Workflows, setzt jedoch Ihren Agent-Socket dem entfernten Host aus, solange die Sitzung aktiv ist.

Schlüsselrotation und -widerruf

Rotation: Erwägen Sie regelmäßig die Rotation Ihrer SSH-Schlüssel, insbesondere für hochsensible Systeme. Dies beinhaltet das Generieren neuer Schlüssel und das Ersetzen der alten öffentlichen Schlüssel auf Servern.
Widerruf: Wenn ein privater Schlüssel kompromittiert wird oder Sie keinen Zugriff mehr benötigen, müssen Sie den entsprechenden öffentlichen Schlüssel aus allen authorized_keys-Dateien auf den Servern entfernen, auf denen er bereitgestellt wurde. Dies ist entscheidend für die Aufrechterhaltung der Sicherheit.

Best Practices und Sicherheitstipps

Verwenden Sie Passphrasen: Schützen Sie Ihre privaten Schlüssel immer mit starken Passphrasen. Dies ist Ihre primäre Verteidigung gegen unbefugte Nutzung, falls die private Schlüsseldatei gestohlen wird.
Sichere Berechtigungen für private Schlüssel: Stellen Sie sicher, dass Ihre private Schlüsseldatei die Berechtigung 600 hat (-rw-------).
Verwenden Sie ssh-agent: Nutzen Sie den SSH-Agenten, um die wiederholte Eingabe Ihrer Passphrase zu vermeiden.
Deaktivieren Sie die Passwortauthentifizierung: Sobald die SSH-Schlüsselauthentifizierung funktioniert, erwägen Sie, die passwortbasierte Authentifizierung auf Ihren Servern zu deaktivieren, um eine zusätzliche Sicherheitsebene zu schaffen.
Halten Sie Schlüssel aktuell: Verwenden Sie moderne, starke Algorithmen wie Ed25519. Vermeiden Sie ältere RSA-Schlüssel ohne ausreichende Bitlänge (mindestens 4096).
Achten Sie auf authorized_keys: Fügen Sie nur öffentliche Schlüssel aus vertrauenswürdigen Quellen zu Ihrer authorized_keys-Datei hinzu.
Regelmäßige Audits: Überprüfen Sie regelmäßig die authorized_keys-Dateien auf Ihren Servern, um sicherzustellen, dass nur autorisierte Schlüssel vorhanden sind.

Fazit

SSH-Schlüssel sind es wert, eingerichtet zu werden, bevor Sie einen Notfall-Serverzugriff benötigen. Generieren Sie einen modernen Schlüssel, schützen Sie den privaten Schlüssel mit einer Passphrase, kopieren Sie nur den öffentlichen Schlüssel auf Server und entfernen Sie veraltete Schlüssel aus authorized_keys, wenn sich der Zugriff ändert.