SSH-Schlüsselauthentifizierung verstehen: Öffentliche vs. Private Schlüssel erklärt

SSH (Secure Shell) ist das Rückgrat des sicheren Remote-Zugriffs auf Server und ermöglicht Administratoren und Entwicklern die Verwaltung von Systemen von überall aus. Obwohl die passwortbasierte Authentifizierung eine gängige Methode ist, birgt sie oft Sicherheitslücken. Die branchenweit bevorzugte und wesentlich sicherere Alternative ist die SSH-Schlüsselauthentifizierung.

Dieser Artikel soll die SSH-Schlüsselauthentifizierung entmystifizieren, indem er die grundlegenden Rollen von öffentlichen und privaten Schlüsseln klar erklärt. Wir werden untersuchen, wie diese kryptografischen Gegenstücke zusammenarbeiten, um Ihre Remote-Verbindungen zu sichern und eine robuste Verteidigung gegen unbefugten Zugriff zu bieten. Am Ende werden Sie verstehen, warum diese Methode nicht nur sicherer ist als herkömmliche passwortbasierte Anmeldungen, sondern auch bequemer für den täglichen Gebrauch.

Das Problem mit Passwörtern

Die traditionelle passwortbasierte Authentifizierung stützt sich auf ein gemeinsames Geheimnis: das Passwort. Obwohl starke Passwörter ein angemessenes Sicherheitsniveau bieten können, sind sie anfällig für mehrere Schwächen:

Brute-Force-Angriffe: Angreifer können unzählige Passwortkombinationen ausprobieren, bis sie das richtige erraten.
Wörterbuchangriffe: Mithilfe gängiger Wörter oder Phrasen können Angreifer Konten schnell kompromittieren.
Keylogger: Bösartige Software kann Tastenanschläge erfassen und Passwörter preisgeben.
Phishing: Social-Engineering-Taktiken können Benutzer dazu verleiten, ihre Anmeldeinformationen preiszugeben.
Menschliches Versagen: Benutzer wählen oft schwache, leicht zu erratende oder wiederverwendete Passwörter und geben sie möglicherweise versehentlich preis.

Die SSH-Schlüsselauthentifizierung mildert diese Risiken, indem sie die Notwendigkeit eliminiert, ein Geheimnis über das Netzwerk zu übertragen, was sie zu einer überlegenen Wahl für die Sicherung Ihrer Remote-Infrastruktur macht.

SSH-Schlüsselauthentifizierung: Ein Überblick

Die SSH-Schlüsselauthentifizierung nutzt die asymmetrische Kryptografie, ein System, das ein Paar mathematisch verknüpfter Schlüssel verwendet: einen öffentlichen Schlüssel und einen privaten Schlüssel. Im Gegensatz zur symmetrischen Kryptografie, bei der derselbe Schlüssel sowohl für die Verschlüsselung als auch für die Entschlüsselung verwendet wird, verwendet die asymmetrische Kryptografie einen Schlüssel zur Verschlüsselung und einen anderen, aber verwandten Schlüssel zur Entschlüsselung.

Wenn Sie versuchen, sich mit Schlüsseln bei einem SSH-Server anzumelden, fordert der Server Ihren Client heraus, und Ihr Client beweist seine Identität mithilfe seines privaten Schlüssels, ohne den privaten Schlüssel selbst über das Netzwerk zu senden. Dieser Prozess stellt sicher, dass nur Clients, die im Besitz des richtigen privaten Schlüssels sind, eine Verbindung mit Servern herstellen können, die so konfiguriert sind, dass sie den entsprechenden öffentlichen Schlüssel vertrauen.

Das kryptografische Duo: Öffentliche und Private Schlüssel

Im Zentrum der SSH-Schlüsselauthentifizierung stehen diese beiden unterschiedlichen, aber miteinander verbundenen Komponenten.

Der Private Schlüssel

Der private Schlüssel ist Ihre geheime Identität. Es handelt sich um eine lange, komplexe Zeichenfolge, die absolut vertraulich behandelt und niemals weitergegeben werden darf. Betrachten Sie ihn als den einzigartigen Schlüssel zu Ihrer digitalen verschlossenen Box.

Sicherheitskritisch: Wenn Ihr privater Schlüssel kompromittiert wird, könnte ein Angreifer Sie imitieren und unbefugten Zugriff auf jeden Server erhalten, auf dem der entsprechende öffentliche Schlüssel bereitgestellt wurde.
Speicherort: Typischerweise auf Ihrem lokalen Rechner gespeichert (z. B. ~/.ssh/id_rsa, ~/.ssh/id_ed25519).
Schutz: Er wird oft durch eine Passphrase geschützt, was eine zusätzliche Sicherheitsebene darstellt. Selbst wenn ein Angreifer Zugriff auf Ihre private Schlüsseldatei erhält, kann er sie ohne die Passphrase nicht verwenden.

Der Öffentliche Schlüssel

Der öffentliche Schlüssel ist das Gegenstück zu Ihrem privaten Schlüssel. Er wird aus Ihrem privaten Schlüssel abgeleitet, kann jedoch nicht verwendet werden, um den privaten Schlüssel neu zu erstellen. Wie der Name schon sagt, soll der öffentliche Schlüssel weitergegeben und auf jedem Server hinterlegt werden, auf den Sie zugreifen möchten.

Weitergabefähig: Sie können Ihren öffentlichen Schlüssel gefahrlos an jeden oder jeden Server verteilen, ohne Ihre Sicherheit zu gefährden.
Speicherort: Auf dem Server werden öffentliche Schlüssel typischerweise in der Datei ~/.ssh/authorized_keys für jedes Benutzerkonto gespeichert. Jede Zeile in dieser Datei repräsentiert einen vertrauenswürdigen öffentlichen Schlüssel.
Rolle: Der öffentliche Schlüssel fungiert als digitaler Fingerabdruck. Wenn Sie versuchen, eine Verbindung herzustellen, verwendet der Server Ihren öffentlichen Schlüssel, um zu überprüfen, ob Sie den passenden privaten Schlüssel besitzen, ohne den privaten Schlüssel selbst jemals zu sehen.

Wie die SSH-Schlüsselauthentifizierung funktioniert: Der Handshake

Lassen Sie uns den Schritt-für-Schritt-Prozess aufschlüsseln, mit dem die SSH-Schlüsselauthentifizierung eine sichere Verbindung herstellt:

Schlüsselpaar-Generierung: Zuerst generieren Sie auf Ihrem lokalen Rechner ein öffentliches und privates Schlüsselpaar. Der private Schlüssel bleibt geheim, und der öffentliche Schlüssel wird verteilt.
Bereitstellung des öffentlichen Schlüssels: Sie kopieren Ihren öffentlichen Schlüssel auf den Remote-Server, auf den Sie zugreifen möchten. Dieser Schlüssel wird normalerweise zur Datei ~/.ssh/authorized_keys im Home-Verzeichnis Ihres Benutzers auf dem Server hinzugefügt.
Verbindungsversuch: Wenn Sie eine SSH-Verbindung von Ihrem lokalen Rechner zu dem Remote-Server initiieren, teilt Ihr SSH-Client mit, dass er sich per Schlüssel authentifizieren möchte.
Server-Herausforderung: Der Server, der Ihren öffentlichen Schlüssel besitzt, generiert eine zufällige Zeichenfolge (eine „Challenge“) und verschlüsselt diese mit Ihrem öffentlichen Schlüssel.
Client-Antwort: Der Server sendet diese verschlüsselte Challenge an Ihren SSH-Client. Ihr Client verwendet dann Ihren privaten Schlüssel, um die Challenge zu entschlüsseln.
Verifizierung: Ihr Client verschlüsselt daraufhin die ursprüngliche Zufallszeichenfolge (oder einen Ableitung davon, zusammen mit Sitzungsdaten) mit Ihrem privaten Schlüssel und sendet sie an den Server zurück. Der Server verwendet Ihren öffentlichen Schlüssel, um diese Antwort zu entschlüsseln. Wenn der entschlüsselte Wert mit der ursprünglichen Challenge übereinstimmt, ist der Server überzeugt, dass Sie im Besitz des korrekten privaten Schlüssels sind.
Authentifizierung gewährt: Wenn die Überprüfung erfolgreich ist, gewährt der Server Ihnen den Zugriff und eine sichere SSH-Sitzung wird aufgebaut.

Wichtig ist, dass Ihr privater Schlüssel während dieses gesamten Prozesses niemals Ihren lokalen Rechner verlässt. Es werden nur kryptografische Nachweise ausgetauscht, die von ihm abgeleitet wurden.

Generieren eines SSH-Schlüsselpaars

Das Generieren eines SSH-Schlüsselpaars ist ein unkomplizierter Prozess mithilfe des Befehls ssh-keygen auf Ihrem lokalen Rechner (Linux, macOS oder WSL/Git Bash unter Windows).

ssh-keygen -t ed25519 -C "[email protected]"

-t ed25519: Gibt den zu erstellenden Schlüsseltyp an. ed25519 ist ein moderner, hochsicherer und effizienter Algorithmus. rsa ist ebenfalls verbreitet, aber ed25519 wird heute im Allgemeinen bevorzugt.
-C "[email protected]": Fügt dem öffentlichen Schlüssel einen Kommentar hinzu, der hilft, seinen Zweck oder Besitzer zu identifizieren.

Sie werden aufgefordert, eine Datei zum Speichern des Schlüssels anzugeben (Standard ist ~/.ssh/id_ed25519) und eine Passphrase einzugeben. Verwenden Sie immer eine starke Passphrase, um Ihren privaten Schlüssel zu schützen.

Generiere öffentliches/privates ed25519 Schlüsselpaar.
Datei zum Speichern des Schlüssels angeben (~/.ssh/id_ed25519):
Verzeichnis „/home/youruser/.ssh“ wurde erstellt.
Passphrase eingeben (leer für keine Passphrase):
Passphrase erneut eingeben:
Ihre Identität wurde in /home/youruser/.ssh/id_ed25519 gespeichert.
Ihr öffentlicher Schlüssel wurde in /home/youruser/.ssh/id_ed25519.pub gespeichert.
Der Schlüssel-Fingerabdruck ist: SHA256:...
Das Randomart-Bild des Schlüssels ist:
+--[ED25519 256]----+ 
|      .=+          |
|     . o. .        |
|    . + o.         |
|   o = B o.        |
|  . S @ + +        |
|   = + B .         |
|  o * * E          |
| . o o             |
|  . .              |
+----[SHA256]-------+

Nach der Generierung finden Sie zwei Dateien in Ihrem ~/.ssh-Verzeichnis:

id_ed25519 (Ihr privater Schlüssel)
id_ed25519.pub (Ihr öffentlicher Schlüssel)

Warnung: Stellen Sie sicher, dass Ihre private Schlüsseldatei (id_ed25519) strenge Berechtigungen hat (z. B. chmod 600 ~/.ssh/id_ed25519), sodass nur Sie sie lesen/schreiben können.

Bereitstellung Ihres öffentlichen Schlüssels

Um die Schlüsselauthentifizierung zu nutzen, muss Ihr öffentlicher Schlüssel auf dem Remote-Server abgelegt werden, auf den Sie zugreifen möchten.

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

Das Dienstprogramm ssh-copy-id ist der einfachste und sicherste Weg, Ihren öffentlichen Schlüssel bereitzustellen. Es kümmert sich um die Erstellung des ~/.ssh-Verzeichnisses und der authorized_keys-Datei mit den korrekten Berechtigungen, falls diese noch nicht existieren.

ssh-copy-id -i ~/.ssh/id_ed25519.pub user@remote_host

Ersetzen Sie user durch Ihren Benutzernamen auf dem Remote-Server und remote_host durch die IP-Adresse oder den Hostnamen des Servers. Sie werden ein letztes Mal nach Ihrem Passwort für user@remote_host gefragt, um den Schlüssel hochzuladen.

Manuelle Bereitstellung

Wenn ssh-copy-id nicht verfügbar ist, können Sie den öffentlichen Schlüssel manuell kopieren:

Kopieren Sie den Inhalt des öffentlichen Schlüssels: Zeigen Sie Ihren öffentlichen Schlüssel mit cat an.
bash cat ~/.ssh/id_ed25519.pub
Kopieren Sie die gesamte Ausgabe, die mit ssh-ed25519 ... beginnt und mit Ihrem Kommentar endet.
Melden Sie sich über passwortbasierte Authentifizierung beim Remote-Server an:
bash ssh user@remote_host
Geben Sie Ihr Passwort ein, wenn Sie dazu aufgefordert werden.
Erstellen Sie das ~/.ssh-Verzeichnis und die authorized_keys-Datei, falls sie nicht existieren:
bash mkdir -p ~/.ssh chmod 700 ~/.ssh touch ~/.ssh/authorized_keys chmod 600 ~/.ssh/authorized_keys
Fügen Sie Ihren öffentlichen Schlüssel an authorized_keys an: Fügen Sie den zuvor kopierten Inhalt des öffentlichen Schlüssels in die Datei authorized_keys ein.
bash echo "ssh-ed25519 AAAA..." >> ~/.ssh/authorized_keys
(Ersetzen Sie ssh-ed25519 AAAA... durch Ihren tatsächlichen öffentlichen Schlüsselinhalt)

Verbindung mit SSH-Schlüsseln

Sobald Ihr öffentlicher Schlüssel auf dem Server hinterlegt ist, können Sie sich einfach durch Angabe von Benutzer und Host verbinden:

ssh user@remote_host

Wenn Sie mehrere Schlüsselpaare haben oder sich Ihr privater Schlüssel nicht am Standardspeicherort befindet (~/.ssh/id_rsa oder ~/.ssh/id_ed25519), müssen Sie ihn möglicherweise mit der Option -i angeben:

ssh -i ~/.ssh/my_custom_key user@remote_host

Wenn Ihr privater Schlüssel durch eine Passphrase geschützt ist, werden Sie aufgefordert, diese einzugeben. Um die wiederholte Eingabe der Passphrase während einer Sitzung zu vermeiden, können Sie ssh-agent verwenden.

Sicherheitsvorteile der SSH-Schlüsselauthentifizierung

Eliminiert das Raten von Passwörtern: Da Passwörter nicht zur Authentifizierung verwendet werden, werden Brute-Force-Angriffe auf Ihr Passwort unmöglich.
Stärkere Anmeldeinformationen: SSH-Schlüssel sind typischerweise kryptografische Werte von 2048 Bit (RSA) oder 256 Bit (Ed25519) und somit weitaus komplexer und schwerer zu knacken als selbst die stärksten menschengenerierten Passwörter.
Keine Übertragung von Geheimnissen: Ihr privater Schlüssel verlässt niemals Ihren lokalen Rechner, was das Risiko, dass er während der Authentifizierung abgefangen oder gestohlen wird, erheblich reduziert.
Automatisierungsfreundlich: Schlüssel ermöglichen passwortlose, skriptfähige Anmeldungen, was für Automatisierungstools und CI/CD-Pipelines unerlässlich ist.
Passphrasenschutz: Das Hinzufügen einer Passphrase zu Ihrem privaten Schlüssel bietet eine zusätzliche Sicherheitsebene. Selbst wenn Ihre private Schlüsseldatei gestohlen wird, ist sie ohne die Passphrase unbrauchbar.

Verwaltung Ihrer SSH-Schlüssel

`ssh-agent`

ssh-agent ist ein Programm, das im Hintergrund läuft und Ihre entschlüsselten privaten Schlüssel im Speicher hält. Wenn Sie versuchen, sich bei einem SSH-Server anzumelden, kann Ihr SSH-Client den ssh-agent nach dem erforderlichen privaten Schlüssel fragen, wodurch die wiederholte Eingabe Ihrer Passphrase entfällt.

Um ssh-agent zu starten und Ihren Schlüssel hinzuzufügen:

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

Sie geben Ihre Passphrase einmal ein, wenn Sie den Schlüssel zum Agenten hinzufügen.

Schlüsselbenennung und Organisation

Um mehrere Schlüssel zu verwalten (z. B. für verschiedene Organisationen, Projekte oder den persönlichen Gebrauch), sollten Sie aussagekräftige Namen verwenden:

ssh-keygen -t ed25519 -f ~/.ssh/id_work_project -C "work_project_key"
ssh-keygen -t ed25519 -f ~/.ssh/id_personal_github -C "personal_github_key"

Sie können dann mit der Option -i angeben, welchen Schlüssel Sie verwenden möchten, oder Ihre Datei ~/.ssh/config konfigurieren, um automatisch den richtigen Schlüssel basierend auf dem Host auszuwählen.

Beispiel für ~/.ssh/config:

Host github.com
    IdentityFile ~/.ssh/id_personal_github
    User git

Host work-server
    Hostname 192.168.1.100
    IdentityFile ~/.ssh/id_work_project
    User devuser

Best Practices und Tipps

Teilen Sie Ihren privaten Schlüssel niemals: Dies ist die goldene Regel. Ihr privater Schlüssel ist Ihre digitale Identität.
Verwenden Sie eine starke Passphrase: Schützen Sie Ihren privaten Schlüssel mit einer robusten Passphrase, ähnlich einem starken Passwort. Dies macht Ihren Schlüssel unbrauchbar, selbst wenn er in falsche Hände gerät.
Schlüssel regelmäßig rotieren: Generieren Sie periodisch neue Schlüssel und widerrufen Sie alte, insbesondere wenn Sie vermuten, dass ein Schlüssel kompromittiert wurde.
Dateiberechtigungen einschränken: Stellen Sie sicher, dass Ihre private Schlüsseldatei die Berechtigungen 600 (rw-------) und Ihr ~/.ssh-Verzeichnis die Berechtigungen 700 (rwx------) hat.
Passwortauthentifizierung auf Servern deaktivieren: Sobald Sie die Schlüsselauthentifizierung eingerichtet haben, sollten Sie in Erwägung ziehen, die Passwortauthentifizierung für SSH auf Ihren Servern zu deaktivieren, um die Sicherheit drastisch zu erhöhen. Dies geschieht häufig durch Setzen von PasswordAuthentication no in /etc/ssh/sshd_config.
Verwenden Sie ssh-agent: Nutzen Sie der Bequemlichkeit und Sicherheit halber ssh-agent zur Verwaltung Ihrer Schlüssel, insbesondere solcher mit Passphrasen.

Fazit

Die SSH-Schlüsselauthentifizierung bietet eine robuste, sichere und bequeme Methode für den Zugriff auf Remote-Server. Indem Sie die unterschiedlichen Rollen von öffentlichen und privaten Schlüsseln und deren Zusammenspiel beim kryptografischen Handshake verstehen, können Sie Ihre Betriebssicherheit erheblich verbessern. Der Übergang von passwortbasierten Anmeldungen zu SSH-Schlüsseln ist ein grundlegender Schritt hin zu einer besseren Serververwaltung und Schutz vor gängigen Angriffsvektoren. Nutzen Sie diesen leistungsstarken Sicherheitsmechanismus, um Ihre digitale Infrastruktur zu schützen.