SSH-Schlüssel erklärt: Leitfaden für schnellen und sicheren Fernzugriff

Bist du es leid, jedes Mal dein Passwort einzugeben, wenn du dich mit einem Remote-Server oder einem GitHub-Repository verbindest?

SSH-Schlüssel sind das, wonach du suchst. Sie bieten eine sichere und bequeme Alternative zur passwortbasierten Authentifizierung, wenn du auf entfernte Systeme zugreifen willst. SSH-Schlüssel bieten außerdem mehr Sicherheit als Passwörter, da sie praktisch nicht durch Brute-Force-Angriffe zu knacken sind.

Im Laufe der Jahre haben sie sich zum Standard für sichere Fernverbindungen in professionellen Umgebungen entwickelt. Sie sind unverzichtbar für alle, die mit entfernten Servern, Cloud-Diensten oder Versionskontrollsystemen wie Git arbeiten.

In diesem Artikel erfährst du, wie du SSH-Schlüssel generierst, sie zu entfernten Systemen hinzufügst und Best Practices für die sichere Verwaltung dieser Schlüssel implementierst.

Was sind SSH-Schlüssel?

SSH-Schlüssel sind kryptografische Zugangsdaten, mit denen du sicher auf entfernte Systeme zugreifen kannst, ohne Passwörter einzugeben. Anstatt dir also komplexe Passwörter mit Zahlen, Großbuchstaben und Sonderzeichen zu merken, erstellst du ein Schlüsselpaar - einen öffentlichen und einen privaten.

Stell dir deinen öffentlichen Schlüssel wie ein Vorhängeschloss vor, das du frei an jeden Server verteilen kannst, auf den du zugreifen willst. Dein privater Schlüssel funktioniert wie der einzigartige Schlüssel, der diese Vorhängeschlösser öffnet. Wenn du dich mit einem entfernten System verbindest, prüft es, ob dein privater Schlüssel mit seinem gespeicherten öffentlichen Schlüssel übereinstimmt. Wenn sie übereinstimmen, erhältst du sofortigen Zugang, ohne ein Passwort eingeben zu müssen.

Der öffentliche Schlüssel kann nicht verwendet werden, um deinen privaten Schlüsselzu ermitteln, was dieses System extrem sicher macht. Dein privater Schlüssel sollte geheim bleiben und auf deinem Computer bleiben, also gib ihn bitte niemals an andere weiter.

> Um besser zu verstehen, wie sichere Verbindungen in die breitere Landschaft der Cybersicherheit passen, solltest du denden Kurs Einführung in die Datensicherheit.

Wenn es um die Vorteile im Vergleich zur herkömmlichen Passwortauthentifizierung geht, solltest du diese kennen:

• Erhöhte Sicherheit - Im Gegensatz zu Passwörtern können SSH-Schlüssel aufgrund ihrer Länge und Komplexität (normalerweise 2048 Bit oder mehr) nicht erraten oder erzwungen werden.
• Verbesserter Komfort - Einmal eingerichtet, kannst du dich mit Servern verbinden, ohne jedes Mal ein Passwort eingeben zu müssen.
• Automatisierungsfreundlich - Perfekt für Skripte und automatisierte Prozesse, die eine sichere Authentifizierung benötigen.
• Zentralisierte Zugangsverwaltung - Füge den Zugang hinzu oder entziehe ihn, indem du einfach öffentliche Schlüssel auf deinen Servern verwaltest.
• Keine Passwort-Müdigkeit mehr - Du musst keine komplexen Passwörter mehr erstellen, merken oder regelmäßig ändern.

SSH-Schlüssel funktionieren mit praktisch jedem System, das SSH unterstützt, darunter Linux-Server, Cloud-Plattformen und Code-Repositories wie GitHub und GitLab. Sie sind zum Standard für den sicheren Fernzugriff in professionellen Umgebungen geworden.

> Für Cloud-Experten ist es wichtig, sowohl die Sicherheit als auch die Kosteneffizienz zu beherrschen.rn mehr im Kurs AWS Security and Cost Management.

Jetzt weißt du, was SSH-Schlüssel sind. Als Nächstes lernst du, wie du sie erzeugst.

Wie man SSH-Schlüssel erzeugt

Das Erstellen von SSH-Schlüsseln dauert nur ein paar Minuten, unabhängig von deinem Betriebssystem. 

Dabei werden zwei Dateien erzeugt: dein privater Schlüssel (der sicher auf deinem Computer verbleiben muss) und dein öffentlicher Schlüssel (den du auf entfernten Servern hinzufügen wirst).

SSH-Schlüssel unter Linux/MacOS generieren

Um SSH-Schlüssel unter Linux oder MacOS zu erstellen, verwendest du den integrierten Befehl ssh-keygen.  Um zu beginnen, öffne dein Terminal und gib ein:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Mit diesem Befehl wird dein System angewiesen, einen neuen RSA-Schlüssel mit 4096-Bit-Verschlüsselung (sehr sicher) zu erstellen und deine E-Mail als Kommentar zur Identifizierung hinzuzufügen.

Dein System wird dich fragen, wo du den Schlüssel speichern willst und ob du eine Passphrase hinzufügen willst. Der Standard-Speicherort funktioniert für die meisten Nutzer gut, aber diePassphrase ist eine Überlegung wert .

Eine gute Passphrase bietet eine zusätzliche Sicherheitsebene - selbst wenn jemand deine private Schlüsseldatei bekommt, kann er sie nicht benutzen, ohne diese Phrase zu kennen.

Abbildung 1 - SSH-Schlüsselpaar unter Linux/macOS erstellen

Nachdem du deine Auswahl bestätigt hast, erstellt dein System beide Schlüssel im Verzeichnis .ssh deines Home-Ordners:

• Dein privater Schlüssel: Die Datei ohne Erweiterung (wie id_rsa).
• Dein öffentlicher Schlüssel: Die Datei mit der Erweiterung .pub (wie id_rsa.pub).

Abbildung 2 - Erstellte Schlüsseldateien

SSH-Schlüssel unter Windows generieren

Windows-Nutzer haben zwei gute Möglichkeiten, SSH-Schlüssel zu erstellen - Git Bash und WSL.

Git Bash bietet eine Kommandozeilenumgebung ähnlich wie Linux/MacOS. Wenn du Git für Windows installiert hast, hast du dieses Tool bereits. Öffne die Git Bash und verwende denselben ssh-keygen Befehl wie oben.

Windows Subsystem for Linux (WSL) ist eine weitere gute Option, wenn du lieber in einer Linux-Umgebung auf deinem Windows-Rechner arbeitest. Die Befehle funktionieren genau so wie auf einem nativen Linux-System.

Für diejenigen, die eine grafische Oberfläche bevorzugen,bietet PuTTYgeneinen visuelleren Ansatz.

Abbildung 3 - PuTTYgen Schlüsselgenerierung unter Windows

Hier sind die Schritte, die du unternehmen solltest, um dein Schlüsselpaar zu erstellen:

1. Starte PuTTYgen aus deinem Startmenü.
2. Wähle RSA als deinen Schlüsseltyp.
3. Klicke auf "Erzeugen" und bewege deine Maus in den leeren Bereich.
4. Füge eine Passphrase für zusätzliche Sicherheit hinzu.
5. Speichere sowohl deinen öffentlichen als auch deinen privaten Schlüssel mit den entsprechenden Schaltflächen.

Abbildung 4 - Erstellte Schlüsseldateien (2)

Die wichtigsten Dateien verstehen

Bei der SSH-Schlüsselgenerierung werden zwei Dateien erstellt, die als Paar funktionieren.

Dein privater Schlüssel muss geheim und sicher auf deinem Computer bleiben. Sieh ihn als Hauptschlüssel, der deine Identität beweist. Private Schlüssel werden in der Regel ähnlich benannt wie diese:

• id_ed25519 (für Ed25519 Schlüssel).
• id_rsa (für RSA-Schlüssel).

Dein öffentlicher Schlüssel kann frei mit jedem System geteilt werden, auf das du zugreifen möchtest. Es funktioniert wie ein Schloss, das nur dein privater Schlüssel öffnen kann. Öffentliche Schlüssel haben immer den gleichen Namen wie der zugehörige private Schlüssel, plus die Erweiterung .pub.

Die Sicherheit dieses Systems hängt ganz davon ab, dass dein privater Schlüssel geschützt bleibt.

Gib sie niemals weiter, verschicke sie per E-Mail oder speichere sie auf nicht vertrauenswürdigen Geräten. Wenn du glaubst, dass dein privater Schlüssel kompromittiert wurde, erstelle sofort ein neues Schlüsselpaar und aktualisiere alle Server, die deinen alten öffentlichen Schlüssel hatten.

Du kannst den Inhalt deines öffentlichen Schlüssels mit anzeigen:

cat ~/.ssh/id_rsa.pub

Abbildung 5 - Inhalt des öffentlichen Schlüssels

Die Ausgabe zeigt die komplette Zeichenkette, die du für die Konfiguration von Remote-Servern brauchst. Diese werden wir im nächsten Abschnitt besprechen.

SSH-Schlüssel zu entfernten Systemen hinzufügen

Nachdem du nun dein SSH-Schlüsselpaar erstellt hast, musst du deinen öffentlichen Schlüssel zu jedem entfernten System hinzufügen, auf das du zugreifen möchtest. Im Klartext heißt das, dass der Server der Gegenstelle deinen privaten Schlüssel als gültige Form der Authentifizierung anerkennt.

Hinzufügen öffentlicher Schlüssel zu einem entfernten Server

Dieser Vorgang ist nicht besonders kompliziert; du musst nur deinen öffentlichen Schlüssel in eine spezielle Datei auf dem Remote-Server eintragen. Diese Datei mit dem Namen authorized_keys enthält eine Liste der öffentlichen Schlüssel, die für die Verbindung zugelassen sind.

Der einfachste Weg, deinen Schlüssel hinzuzufügen, ist der Befehl ssh-copy-id:

ssh-copy-id username@remote_host

Dieser Befehl stellt eine Verbindung zum Remote-Server her, erstellt die notwendigen Verzeichnisse, falls sie noch nicht existieren, und fügt deinen öffentlichen Schlüssel der Datei authorized_keys hinzu. Während dieses Vorgangs musst du dein Passwort ein letztes Mal eingeben.

Abbildung 6 - Inhalt der authorized_keys Datei

Wenn dein System nicht über den Befehl ssh-copy-id verfügt, kannst du die gleiche Aufgabe auch manuell erledigen, aber das erfordert einige Schritte.

Folge diesen Anweisungen und führe die Befehle nacheinander aus:

# Display your public key and copy it
cat ~/.ssh/id_rsa.pub

# Connect to your remote server with password authentication
ssh username@remote_host

# Create the .ssh directory if it doesn't exist
mkdir -p ~/.ssh

# Open or create the authorized_keys file and paste your public key
echo "your_copied_public_key" >> ~/.ssh/authorized_keys

Und das war's!

Bei Servern, bei denen du deinen Schlüssel einem Systemadministrator zur Verfügung stellen musst, schickst du ihm einfach den Inhalt der Datei mit deinem öffentlichen Schlüssel. Sie fügen es für dich auf dem Server hinzu.

SSH für die Schlüsselauthentifizierung konfigurieren

Nachdem du deinen öffentlichen Schlüssel hinzugefügt hast, möchtest du vielleicht den SSH-Server konfigurieren, um die Sicherheit weiter zu erhöhen. Diese Schritte erfordern administrative (sudo) Rechte.

Um die Konfiguration des SSH-Servers zu bearbeiten, öffne die Hauptkonfigurationsdatei:

sudo nano /etc/ssh/sshd_config

Abbildung 7 - Inhalt der Datei sshd_config

In dieser Datei kannst du eine Reihe von Sicherheitsverbesserungen vornehmen:

• Setze PasswordAuthentication no, um die Passwortanmeldung komplett zu deaktivieren.
• Vergewissere dich, dass PubkeyAuthentication yes eingestellt ist (normalerweise ist es standardmäßig aktiviert).
• Erwäge, PermitRootLogin prohibit-password so einzustellen, dass Root-Logins mit Passwörtern verhindert werden.

Wenn du Änderungen vorgenommen hast, musst du den SSH-Dienst neu starten, damit sie übernommen werden:

sudo systemctl restart sshd

Außerdem ist es wichtig, dass die korrekten Dateiberechtigungen für die SSH-Schlüsselauthentifizierung ausschlaggebend sind, damit sie funktioniert. Der SSH-Server nimmt es mit der Sicherheit sehr genau und lehnt Verbindungen ab, wenn die Berechtigungen zu offen sind. Stelle sicher, dass deine Dateien diese Berechtigungen haben:

• Dein Heimatverzeichnis: chmod 755 ~.
• Das Verzeichnis .ssh: chmod 700 ~/.ssh.
• Die Datei authorized_keys: chmod 600 ~/.ssh/authorized_keys.

Wenn dein öffentlicher Schlüssel vorhanden und der Server richtig konfiguriert ist, kannst du dich jetzt mit entfernten Servern verbinden, ohne dein Passwort einzugeben. 

Im nächsten Abschnitt zeige ich dir, wie du deine SSH-Schlüssel zur Authentifizierung verwendest.

SSH-Schlüssel für die Authentifizierung verwenden

Jetzt kannst du den Komfort und die Sicherheit der passwortlosen Authentifizierung genießen. Sehen wir uns an, wie du dich mit deinen SSH-Schlüsseln mit Servern und Code-Repositories verbinden kannst.

Verbindung zu einem entfernten Server mit SSH-Schlüsselauthentifizierung

Die Verbindung zu einem Server mit SSH-Schlüsseln funktioniert genauso wie der normale SSH-Zugang, nur ohne die Passwortabfrage. Öffne dein Terminal und benutze den Standard SSH-Befehl:

ssh username@hostname

Wenn du deinen Schlüssel im Standardverzeichnis (~/.ssh/id_rsa) gespeichert hast, findet SSH ihn automatisch und verwendet ihn. Wenn du bei der Erstellung deines Schlüssels eine Passphrase festgelegt hast, musst du sie nur einmal pro Sitzung eingeben.

Bei Schlüsseln, die an nicht standardisierten Orten gespeichert sind, gibst du den Pfad mit dem -i Flag an:

ssh -i ~/path/to/your/private_key username@hostname

Abbildung 8 - Verbindung zu einem Remote-Server über SSH

Das Eingeben deiner Passphrase bei jeder Verbindung kann mühsam werden. An dieser Stelle kommt der SSH-Agent zum Einsatz. Sie laufen im Hintergrund und halten deine entschlüsselten privaten Schlüssel sicher im Speicher, sodass du deine Passphrase nur einmal eingeben musst.

So startest du den SSH-Agenten und fügst deinen Schlüssel hinzu:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_rsa

Abbildung 9 - SSH-Agent

Du gibst deine Passphrase einmal ein und der Agent übernimmt die Authentifizierung für alle weiteren Verbindungen während deiner Sitzung. Dies ist nützlich, wenn du dich mehrmals mit Servern verbinden musst oder wenn du Anwendungen verwendest, die mehrere SSH-Verbindungen aufbauen.

Unter macOS startet der SSH-Agent automatisch und du kannst bei der ersten Verbindung die Option "Passphrase im Schlüsselbund speichern" aktivieren, damit du sie bei zukünftigen Sitzungen nicht erneut eingeben musst. Leider ist diese Funktion nur macOS-spezifisch.

SSH-Schlüssel für die GitHub/GitLab-Authentifizierung verwenden

Dienste wie GitHub und GitLab unterstützen auch die SSH-Schlüsselauthentifizierung und empfehlen sie gegenüber der passwortbasierten Authentifizierung.

Um deinen SSH-Schlüssel zu GitHub hinzuzufügen, öffnest du zunächst GitHub und meldest dich bei deinem Konto an. Klicke dann auf dein Profilbild in der oberen rechten Ecke und wähle "Einstellungen". In der Seitenleiste klickst du auf "SSH- und GPG-Schlüssel":

Abbildung 10 - Einrichtung der GitHub-Authentifizierung (1)

Klicke auf "Neuer SSH-Schlüssel", gib deinem Schlüssel einen beschreibenden Titel, füge deinen öffentlichen Schlüssel in das Feld "Schlüssel" ein und klicke schließlich auf "SSH-Schlüssel hinzufügen":

Abbildung 11 - Einrichtung der GitHub-Authentifizierung (2)

Wenn alles erledigt ist, siehst du eine Erfolgsmeldung, die dich darüber informiert, dass der Schlüssel zu deinem Konto hinzugefügt wurde:

Abbildung 12 - Einrichtung der GitHub-Authentifizierung (3)

Nachdem du deinen Schlüssel hinzugefügt hast, kannst du mit SSH-URLs statt mit HTTPS-URLs zu Repositories klonen, ziehen und pushen. Dies ist der Befehl, den du verwenden wirst:

git clone git@github.com:username/repository.git

Abbildung 13 - Klonen eines Repos über SSH

Das ist alles, was es zu sagen gibt. Der Prozess für GitLab ist sehr ähnlich -suche einfach nach SSH-Schlüsseln in deinen Kontoeinstellungen.

Wenn du SSH für Git-Operationen verwendest , musst du nicht jedes Maldeinen Benutzernamen und dein Passwort eingeben, wenn du mit dem entfernten Repository interagierst. Dein SSH-Schlüssel sorgt automatisch für eine sichere Authentifizierung.

Wenn du mit mehreren Diensten arbeitest (z.B. GitHub und GitLab), kannst du für jeden Dienst einen eigenen Schlüssel erstellen. Dieser Ansatz verbessert die Sicherheit, indem er die Gefährdung begrenzt, wenn ein Schlüssel kompromittiert wird.

> Um tiefer in die Verwaltung von Repositories einzutauchen, schaue GitHub-Konzepte für Fortgeschrittene.

SSH-Schlüssel verwalten

Wenn du SSH-Schlüssel für mehrere Systeme und Dienste verwendest, wirst du früher oder später eine Möglichkeit brauchen, sie zu verwalten.

In diesem Abschnitt zeige ich dir, wie du den Überblick über vorhandene Schlüssel behältst, alte oder gefährdete Schlüssel entfernst und mögliche Probleme behebst.

SSH-Schlüssel anzeigen und auflisten

Du kannst alle deine SSH-Schlüssel einsehen, indem du das Verzeichnis .ssh in deinem Home-Ordner überprüfst. Dieses Verzeichnis enthält sowohl deine privaten Schlüssel als auch die dazugehörigen öffentlichen Schlüssel.

Führe den folgenden Befehl aus, um alle Dateien in deinem SSH-Verzeichnis aufzulisten:

ls -la ~/.ssh

Abbildung 14 - Alle Dateien im .ssh-Verzeichnis

Dieser Befehl zeigt alle Dateien im Verzeichnis an, auch die versteckten. Du wirst normalerweise Dateien wie:

• id_rsa - Dein privater RSA-Schlüssel.
• id_rsa.pub - Dein öffentlicher RSA-Schlüssel.
• known_hosts - Eine Liste der Server, mit denen du dich verbunden hast.
• authorized_keys - Öffentliche Schlüssel, die auf diesen Rechner zugreifen können (wenn er als Server eingerichtet ist).
• config - Deine SSH-Client-Konfiguration (falls du eine erstellt hast).

Wenn du mehrere Schlüssel für verschiedene Dienste erstellt hast, siehst du zusätzliche Schlüsselpaare mit Namen, die du bei der Erstellung angegeben hast.

Um zu prüfen, was ein bestimmter öffentlicher Schlüssel enthält, führe den folgenden Befehl aus:

cat ~/.ssh/id_rsa.pub

Abbildung 15 - Inhalt des öffentlichen Schlüssels

Hier wird der vollständige öffentliche Schlüssel angezeigt, der mit ssh-rsa beginnt und mit deinem Kommentar endet (normalerweise deine E-Mail-Adresse).

SSH-Schlüssel entfernen

Im Laufe der Zeit kann es sein, dass du SSH-Schlüssel aus verschiedenen Gründen entfernen musst - vielleicht stellst du auf einen stärkeren Schlüsseltyp um, ein Gerät ist verloren gegangen oder du brauchst keinen Zugang mehr zu bestimmten Systemen.

Um Schlüssel von einem entfernten Server zu entfernenzu entfernen, musst du die Datei authorized_keys bearbeiten:

# Connect to the remote server
ssh username@remote_host

#  Open the authorized_keys file:
nano ~/.ssh/authorized_keys

Für GitHub und GitLabist es sogar noch einfacher, Schlüssel zu entfernen:

1. Gehe zu deinen Kontoeinstellungen.
2. Navigiere zum Abschnitt "SSH- und GPG-Schlüssel".
3. Finde den Schlüssel, den du entfernen möchtest.
4. Klicke auf das Löschsymbol neben dem Schlüssel.

Abbildung 16 - Bestätigen des Löschens von Schlüsseln auf GitHub

Und schließlich, um Schlüssel von deinem lokalen Rechner zu entfernenlöschst du einfach die Dateien:

rm ~/.ssh/id_rsa ~/.ssh/id_rsa.pub

Ersetze id_rsa durch den Namen des Schlüssels, den du entfernen möchtest.

Wenn du einen Remote-Host aus deiner known_hosts Datei entfernen musst (normalerweise nachdem ein Server neu konfiguriert wurde), führe diesen Befehl aus:

ssh-keygen -R hostname

Damit wird der Eintrag des angegebenen Hosts aus der Datei known_hosts entfernt. Das ist praktisch, wenn du die Fehlermeldung "host key verification failed" erhältst.

Fehlersuche bei häufigen SSH-Schlüsselproblemen

Die SSH-Schlüsselauthentifizierung kann manchmal aus allen möglichen Gründen fehlschlagen. In diesem Abschnitt zeige ich dir Lösungen für häufige Probleme.

• Genehmigungsfragen. SSH ist aus Sicherheitsgründen streng bei den Dateiberechtigungen. Wenn deine Schlüssel falsche Berechtigungen haben, schlägt die Authentifizierung fehl. Repariere das mit:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys

• Probleme mit der Passphrase. Wenn du deine Passphrase vergessen hast, gibt es leider keine Möglichkeit, sie wiederherzustellen. Du musst die folgenden Schritte ausführen:
• Erstelle ein neues Schlüsselpaar.
• Füge den neuen öffentlichen Schlüssel zu deinen entfernten Systemen hinzu.
• Entferne das alte Schlüsselpaar.

• Verbindung verweigert. Wenn du die Fehlermeldung "Verbindung verweigert" erhältst, kann das viele Gründe haben. Hier sind die Schritte, die du unternehmen solltest, um sie zu umgehen:
• Überprüfe, ob der Server läuft und erreichbar ist.
• Überprüfe, ob der SSH-Dienst auf dem Server läuft.
• Vergewissere dich, dass du den richtigen Port verwendest (Standard ist 22).

• Authentifizierungsfehler. Wenn du die Fehlermeldung "Permission denied (publickey)" erhältst, führe diese Schritte aus, um das Problem zu umgehen:
• Vergewissere dich, dass dein öffentlicher Schlüssel ordnungsgemäß in der Datei authorized_keys des Servers eingetragen ist.
• Prüfe, ob der Server die Authentifizierung mit öffentlichen Schlüsseln zulässt.
• Überprüfe, ob du den richtigen Benutzernamen und Hostnamen verwendest.
• Vergewissere dich, dass du den richtigen privaten Schlüssel verwendest.

• Der Agent stelltaus. Diese Probleme können auftreten, wenn der SSH-Agent nicht funktioniert. Das solltest du tun:
• Bestätige, dass der Agent mit ssh-add -l läuft.
• Wenn er nicht läuft, starte ihn mit eval "$(ssh-agent -s)".
• Füge deinen Schlüssel mit ssh-add ~/.ssh/id_rsa hinzu.

Als Nächstes wollen wir uns einige Best Practices für die SSH-Schlüsselverwaltung ansehen.

Best Practices für die SSH-Schlüsselverwaltung

Die SSH-Authentifizierung ist großartig, um deine Systeme vor unerwünschten Zugriffen zu schützen, aber seien wir mal ehrlich - manchmal kann sie auch ein bisschen lästig sein. Bei den folgenden Tipps geht es darum, den goldenen Mittelweg zwischen Sicherheit und Alltagskomfort zu finden.

Starke Passphrasen für SSH-Schlüssel verwenden

Die Passphrase deines privaten Schlüssels ist die letzte Verteidigungslinie, wenn jemand deine Schlüsseldatei in die Hände bekommt. Wähle immer eine starke und einzigartige Passphrase, die schwer zu erraten ist, die du dir aber leicht merken kannst.

Eine gute Passphrase hat diese Eigenschaften:

• Enthält mindestens 12-15 Zeichen.
• Enthält eine Mischung aus Großbuchstaben, Kleinbuchstaben, Zahlen und Sonderzeichen.
• Vermeidet gängige Muster oder Wörter aus dem Wörterbuch.
• Wird nicht von anderen Diensten wiederverwendet.

Für Schlüssel, die auf kritische Systeme oder Produktionsumgebungen zugreifen, ist eine starke Passphrase unerlässlich. Die kleine Unannehmlichkeit, sie gelegentlich zu tippen, überwiegt bei weitem die Sicherheitsrisiken.

Wenn du den SSH-Agenten verwendest, musst du deine Passphrase nur einmal pro Sitzung eingeben. Das macht starke Passphrasen praktisch für den täglichen Gebrauch. Erwäge die Verwendung eines Passwortmanagers, um komplexe Passphrasen sicher zu speichern.

Verschiedene Schlüssel für verschiedene Systeme verwenden

Du solltest immer separate Schlüsselpaare für verschiedene Dienste oder Sicherheitsstufen erstellen, anstatt überall einen einzigen Schlüssel zu verwenden. Diese Aufteilung begrenzt dein Risiko, wenn ein Schlüssel kompromittiert wird.

Du könntest zum Beispiel erstellen:

• Ein Arbeitsschlüssel für die Server deines Unternehmens.
• Ein persönlicher Schlüssel für deine Projekte zu Hause.
• Ein spezieller Schlüssel für GitHub oder GitLab.
• Ein Hochsicherheitsschlüssel für Produktionssysteme.

Auch das ist eine kleine Unannehmlichkeit, aber der zusätzliche Aufwand lohnt sich.

Wenn du mehrere Schlüssel erstellst, verwende aussagekräftige Dateinamen, die den Zweck der Schlüssel angeben:

ssh-keygen -t rsa -b 4096 -f ~/.ssh/github_rsa -C "github access"

Um bei der Verbindung einen bestimmten Schlüssel zu verwenden, kannst du bequem eine Konfigurationsdatei einrichten:

# ~/.ssh/config
Host github.com
    IdentityFile ~/.ssh/github_rsa

Host companyserver
    HostName 255.255.255.255
    User ubuntu
    IdentityFile ~/.ssh/company_server_rsa

Dieser Ansatz garantiert, dass du im Falle einer Kompromittierung eines Schlüssels nur diesen einen Schlüssel ersetzen musst, anstatt alle deine Systeme zu aktualisieren.

SSH-Schlüssel regelmäßig rotieren

Ein regelmäßiger Austausch deiner SSH-Schlüssel verringert das Risiko einer unentdeckten Kompromittierung und entspricht den bewährten Sicherheitsverfahren. 

Wie oft du das machen solltest, hängt von deiner Empfindlichkeit ab:

• Persönliche Projekte: Alle 1-2 Jahre.
• Geschäftssysteme: Alle 6-12 Monate.
• Hochsichere Umgebungen: Alle 3-6 Monate.
• Unmittelbar nachdem Teammitglieder gegangen sind oder verdächtige Aktivitäten festgestellt wurden.

Das Rotieren von SSH-Schlüsseln beinhaltet das Erstellen neuer Schlüsselpaare, das Hinzufügen der neuen öffentlichen Schlüssel zu deinen Servern, das Überprüfen, ob die neuen Schlüssel funktionieren, das Entfernen der alten öffentlichen Schlüssel von den Servern und das Löschen der alten privaten Schlüssel von deinem lokalen Rechner.

Mit anderen Worten: Es braucht etwas Zeit, also plane sie in deinem Zeitplan ein.

Außerdem ist es ratsam, ein Verzeichnis darüber zu führen, welche Schlüssel Zugang zu welchen Systemen haben. Unternehmen sollten die Einführung automatisierter Schlüsselverwaltungsprogramme in Betracht ziehen, die die Rotation systematisch handhaben.

Erzwingen der SSH-Schlüsselauthentifizierung

Die stärkste Sicherheitsmaßnahme, die du ergreifen kannst, ist, die Passwortauthentifizierung auf deinen Servern komplett zu deaktivieren und SSH-Schlüssel für alle Verbindungen zu verlangen.

Befolge diese Schritte, um eine schlüsselbasierte Authentifizierung zu erzwingen:

# Edit your SSH server configuration
sudo nano /etc/ssh/sshd_config

# Set these critical security options
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no

# Restart the SSH service
sudo systemctl restart sshd

Diese Konfiguration verhindert Brute-Force-Angriffe auf Passwörter vollständig. 

Bevor du diese Änderungen vornimmst, solltest du sicherstellen, dass deine SSH-Schlüsselauthentifizierung richtig funktioniert, damit du dichnicht selbst aussperrst. Das kommt vor.

SSH-Schlüssel zusammenfassen

Abschließend kann man sagen, dass SSH-Schlüssel die Art und Weise, wie du dich mit entfernten Systemen verbindest, verändern. Die Umstellung von Passwörtern auf eine schlüsselbasierte Authentifizierung verbessert deine täglichen Arbeitsabläufe mit Sicherheit und Komfort.

Ein weiterer Vorteil ist, dass der Prozess nicht sehr aufwändig ist. Du musst die Schlüssel generieren, sie zu den Servern hinzufügen, auf die du zugreifst, und dich ohne Eingabe von Passwörtern verbinden. Das war's! Im Vergleich zur traditionellen passwortbasierten Authentifizierung machen SSH-Schlüssel deine Verbindungen schneller und zuverlässiger und blockieren außerdem gängige Angriffsmethoden wie das Erraten von Passwörtern.

Denke daran, dass dein privater Schlüssel geschützt werden muss. Verwende eine starke Passphrase, bewahre deinen Schlüssel sicher auf und befolge die in diesem Artikel beschriebenen Best Practices, insbesondere die zur Aufteilung der SSH-Schlüssel. 

Wenn du mehr über SSH-Schlüssel und die Arbeit mit der Kommandozeile im Allgemeinen lernen möchtest, sind diese Kurse von DataCamp die beste Anlaufstelle für dich:

• Einführung in die test-shell
• Einführung in die Bash-Skripterstellung
• Bash & zsh Shell Terminal-Grundlagen Spickzettel