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

SSH-Schlüsselauthentifizierung ist die übliche Methode, mit der viele Administratoren, Entwickler, CI-Systeme und Bereitstellungstools sich auf Servern anmelden. Ihr Laptop speichert einen privaten Schlüssel, der Server speichert den zugehörigen öffentlichen Schlüssel, und SSH beweist, dass Sie den privaten Schlüssel besitzen, ohne ihn über das Netzwerk zu senden.

Dieser letzte Teil ist der entscheidende Punkt. Ein Passwort ist ein Geheimnis, das Sie an vielen Orten eingeben. Ein privater Schlüssel ist ein Geheimnis, das auf Ihrem Rechner bleiben sollte. Wenn Sie ihn mit einer Passphrase schützen und nur den öffentlichen Schlüssel auf Servern speichern, erhalten Sie eine Anmeldemethode, die sowohl sicherer als auch einfacher zu automatisieren ist als gemeinsame Passwörter.

Das Problem mit Passwörtern

Die traditionelle passwortbasierte Authentifizierung beruht auf einem gemeinsamen Geheimnis: dem Passwort. Während starke Passwörter ein angemessenes Sicherheitsniveau bieten können, sind sie anfällig für mehrere Schwachstellen:

Brute-Force-Angriffe: Angreifer können unzählige Passwortkombinationen ausprobieren, bis sie richtig raten.
Wörterbuchangriffe: Durch die Verwendung gebräuchlicher Wörter oder Phrasen können Angreifer schnell Konten kompromittieren.
Keylogger: Schadsoftware kann Tastatureingaben aufzeichnen und so Passwörter preisgeben.
Phishing: Social-Engineering-Taktiken können Benutzer dazu verleiten, ihre Anmeldeinformationen preiszugeben.
Menschliches Versagen: Benutzer wählen oft schwache, erratbare oder wiederverwendete Passwörter und können diese versehentlich preisgeben.

SSH-Schlüsselauthentifizierung reduziert diese Risiken, da das private Geheimnis nicht auf dem entfernten Server eingegeben wird. Das macht Schlüssel nicht magisch. Ein gestohlener unverschlüsselter privater Schlüssel kann immer noch missbraucht werden, und eine schlecht verwaltete authorized_keys-Datei kann zu einer stillen Hintertür werden.

SSH-Schlüsselauthentifizierung: Ein Überblick

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

Wenn Sie sich mit Schlüsseln verbinden, prüft der Server, ob Ihr Konto dem angebotenen öffentlichen Schlüssel vertraut. Ihr Client signiert dann Authentifizierungsdaten mit dem passenden privaten Schlüssel. Der Server überprüft diese Signatur mit dem öffentlichen Schlüssel. Der private Schlüssel wird nicht auf den Server hochgeladen.

Das kryptographische Duo: Öffentliche und private Schlüssel

Im Kern 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 ist eine lange, komplexe Zeichenfolge, die absolut vertraulich behandelt werden muss und niemals mit jemandem geteilt werden darf. Stellen Sie es sich als den einzigartigen Schlüssel zu Ihrem digitalen Safe vor.

Sicherheitskritisch: Wenn Ihr privater Schlüssel kompromittiert wird, könnte ein Angreifer Sie impersonieren und unbefugten Zugriff auf jeden Server erhalten, auf dem der entsprechende öffentliche Schlüssel bereitgestellt wurde.
Speicherort: Normalerweise auf Ihrem lokalen Rechner gespeichert (z.B. ~/.ssh/id_rsa, ~/.ssh/id_ed25519).
Schutz: Er kann durch eine Passphrase geschützt werden. Wenn jemand die Schlüsseldatei kopiert, ist die Passphrase die zusätzliche Barriere zwischen "Datei gestohlen" und "Serverzugriff gestohlen".

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 aber nicht verwendet werden, um den privaten Schlüssel wiederherzustellen. Wie der Name schon sagt, ist der öffentliche Schlüssel zum Teilen gedacht und wird auf jedem Server platziert, auf den Sie zugreifen möchten.

Teilbar: Sie können Ihren öffentlichen Schlüssel sicher an jeden oder jeden Server weitergeben, ohne Ihre Sicherheit zu gefährden.
Speicherort: Auf dem Server werden öffentliche Schlüssel normalerweise 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 ermöglicht es dem Server, eine vom passenden privaten Schlüssel erstellte Signatur zu überprüfen.

Wie SSH-Schlüsselauthentifizierung funktioniert: Der Handshake

Lassen Sie uns den schrittweisen Prozess aufschlüsseln, wie die SSH-Schlüsselauthentifizierung eine sichere Verbindung herstellt:

Schlüsselpaar-Generierung: Zuerst generieren Sie ein Paar aus öffentlichem und privatem Schlüssel auf Ihrem lokalen Rechner. 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 entfernten 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 zum entfernten Server initiieren, gibt Ihr SSH-Client an, dass er sich mit einem Schlüssel authentifizieren möchte.
Serverprüfung: Der Server prüft, ob der angebotene öffentliche Schlüssel für diesen Benutzer zugelassen ist.
Client-Nachweis: Ihr Client signiert Authentifizierungsdaten mit dem privaten Schlüssel. Wenn der private Schlüssel eine Passphrase hat, werden Sie möglicherweise aufgefordert, ihn lokal zu entsperren.
Überprüfung: Der Server überprüft die Signatur mit dem öffentlichen Schlüssel aus authorized_keys. Wenn die Signatur gültig ist und das Konto sich anmelden darf, ist die Authentifizierung erfolgreich.
Authentifizierung gewährt: Wenn die Überprüfung erfolgreich ist, gewährt der Server Ihnen Zugriff, und eine sichere SSH-Sitzung wird hergestellt.

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

Generieren eines SSH-Schlüsselpaares

Das Generieren eines SSH-Schlüsselpaares ist ein unkomplizierter Prozess mit dem Befehl 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 Typ des zu erstellenden Schlüssels an. Ed25519 ist eine moderne Standardeinstellung für die meisten neuen OpenSSH-Schlüssel. RSA ist immer noch üblich, besonders bei älteren Systemen.
-C "[email protected]": Fügt dem öffentlichen Schlüssel einen Kommentar hinzu, der hilft, seinen Zweck oder Besitzer zu identifizieren.

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

Generating public/private ed25519 key pair.
Enter file in which to save the key (~/.ssh/id_ed25519):
Created directory '/home/youruser/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/youruser/.ssh/id_ed25519.
Your public key has been saved in /home/youruser/.ssh/id_ed25519.pub.
The key fingerprint is: SHA256:...
The key's randomart image is:
+--[ED25519 256]----+
|      .=+          |
|     . o. .        |
|    . + o.         |
|   o = B o.        |
|  . S @ + +        |
|   = + B .         |
|  o * * E          |
| . o o             |
|  . .              |
+----[SHA256]-------+

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

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

Stellen Sie sicher, dass Ihre private Schlüsseldatei strenge Berechtigungen hat:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519

Bereitstellen Ihres öffentlichen Schlüssels

Um die Schlüsselauthentifizierung zu nutzen, muss Ihr öffentlicher Schlüssel auf dem entfernten Server platziert 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 erstellt das Verzeichnis ~/.ssh und die Datei authorized_keys mit den richtigen Berechtigungen, falls sie nicht existieren.

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

Ersetzen Sie user durch Ihren Benutzernamen auf dem entfernten Server und remote_host durch die IP-Adresse oder den Hostnamen des Servers. Sie werden nach Ihrem Passwort für user@remote_host ein letztes Mal 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.
```
cat ~/.ssh/id_ed25519.pub
```
Kopieren Sie die gesamte Ausgabe, die mit ssh-ed25519 ... beginnt und mit Ihrem Kommentar endet.
SSH zum entfernten Server mit Passwortauthentifizierung:
```
ssh user@remote_host
```
Geben Sie Ihr Passwort ein, wenn Sie dazu aufgefordert werden.

Erstellen Sie das Verzeichnis ~/.ssh und die Datei authorized_keys, falls sie nicht existieren:

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.
```
echo "ssh-ed25519 AAAA..." >> ~/.ssh/authorized_keys
```
(Ersetzen Sie ssh-ed25519 AAAA... durch den tatsächlichen Inhalt Ihres öffentlichen Schlüssels)

Verbinden mit SSH-Schlüsseln

Sobald Ihr öffentlicher Schlüssel auf dem Server ist, können Sie sich einfach durch Angabe des Benutzers und Hosts verbinden:

ssh user@remote_host

Wenn Sie mehrere Schlüsselpaare haben oder sich Ihr privater Schlüssel nicht am Standardort 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

Reduziert das Risiko von Passwortraten: Wenn die Passwortanmeldung deaktiviert ist, können Angreifer dieses Konto nicht durch SSH-Passwörter per Brute-Force angreifen.
Stärkere Anmeldeinformationen: Ein ordnungsgemäß generierter SSH-Schlüssel kann von einem Menschen nicht erraten werden.
Kein Hochladen des privaten Schlüssels: Ihr privater Schlüssel bleibt während der Authentifizierung lokal.
Automatisierungsfreundlich: Schlüssel ermöglichen skriptbare, passwortlose 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, bleibt sie ohne die Passphrase unbrauchbar.

Verwalten 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, eine Verbindung zu einem SSH-Server herzustellen, kann Ihr SSH-Client ssh-agent nach dem erforderlichen privaten Schlüssel fragen, sodass Sie Ihre Passphrase nicht wiederholt eingeben müssen.

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

Für die Verwaltung mehrerer Schlüssel (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, welcher Schlüssel verwendet werden soll, oder Ihre Datei ~/.ssh/config konfigurieren, um automatisch den richtigen Schlüssel basierend auf dem Host auszuwählen.

Beispiel ~/.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 niemals Ihren privaten Schlüssel: 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 selbst dann unbrauchbar, wenn er in die falschen Hände gerät.
Rotieren Sie, wenn es einen Grund gibt: Generieren Sie einen neuen Schlüssel, wenn ein Gerät verloren geht, ein Auftragnehmer geht, ein Schlüssel versehentlich geteilt wurde oder ein alter Algorithmus nicht mehr Ihrer Richtlinie entspricht.
Beschränken Sie Dateiberechtigungen: Stellen Sie sicher, dass Ihre private Schlüsseldatei die Berechtigung 600 (rw-------) und Ihr Verzeichnis ~/.ssh die Berechtigung 700 (rwx------) hat.
Deaktivieren Sie die Passwortauthentifizierung vorsichtig: Sobald die Schlüsselanmeldung von einem zweiten Terminal aus funktioniert, sollten viele Server PasswordAuthentication no in /etc/ssh/sshd_config setzen. Behalten Sie den Konsolenzugriff bei, bevor Sie dies auf entfernten Systemen ändern.
Verwenden Sie ssh-agent: Verwenden Sie aus Bequemlichkeit und Sicherheit ssh-agent, um Ihre Schlüssel zu verwalten, insbesondere solche mit Passphrasen.

Ein einfaches mentales Modell

Der öffentliche Schlüssel ist das Schloss, das Sie auf dem Serverkonto installieren. Der private Schlüssel ist die Berechtigung, die Sie auf Ihrem eigenen Rechner behalten. Die Passphrase schützt diese Berechtigung, falls die Datei kopiert wird. Die Datei authorized_keys ist die Zugriffsliste.

Die meisten SSH-Schlüsselprobleme entstehen durch Verwechslungen: Kopieren des privaten Schlüssels auf den Server, Einfügen des öffentlichen Schlüssels unter dem falschen Benutzer, Verwenden der falschen Identitätsdatei oder zu offene Berechtigungen, die OpenSSH nicht vertrauen kann. Benennen Sie Schlüssel nach Zweck, schützen Sie private Schlüssel mit Passphrasen, verwenden Sie ssh-agent für Bequemlichkeit, entfernen Sie alte öffentliche Schlüssel, wenn der Zugriff enden soll, und testen Sie Änderungen von einem zweiten Terminal aus, bevor Sie die Passwortanmeldung deaktivieren.