Verwendung eines SSH-Keys mit GitHub
Die Verwendung eines SSH-Keys mit GitHub ermöglicht den passwortlosen Zugriff auf Git-Repositories. Anstatt einen Nutzer per Nutzername und Passwort auszuweisen, wird die Entwicklermaschine über den SSH-Key authentifiziert.
Lassen Sie sich von den Vorteilen überzeugen. Probieren Sie Ihren Virtual Server ganz in Ruhe 30 Tage lang aus!
Was ist ein SSH-Key?
Bei der Secure Shell (SSH) handelt es sich um das Standard-Tool für verschlüsselten Zugriff auf entfernte Systeme. SSH ermöglicht das Einloggen auf einem Server von der heimischen Entwicklermaschine aus. Git nutzt SSH als Übertragungsprotokoll und erlaubt lesenden und schreibenden Zugriff auf Remote-Repositories.
Um die Authentifizierung der Maschine zu ermöglichen und die Fälschungssicherheit der übertragenen Daten sicherzustellen, kommt eine verschlüsselte Verbindung zum Einsatz. Ohne diese wäre es Fremden möglich, beliebige Änderungen an Repositories vorzunehmen.
Git per SSH nutzt asymmetrische Verschlüsselung als kryptografisches Verfahren. Dabei wird zunächst ein Paar aus privatem und öffentlichem Schlüssel erstellt. Man spricht auch von einem „Public-Private Keypair“. Der private Schlüssel verbleibt auf dem eigenen Rechner. Der öffentliche Schlüssel wird mit dritten Parteien, z. B. GitHub, geteilt.
Nutzt man einen SSH-Key zum Zugriff auf GitHub-Repositories, entfällt die Eingabe eines Kennworts. Generell gilt passwortloses Anmelden als sicherer, da kein Passwort durch Keylogger oder Trojaner abgegriffen werden kann. Statt einer Person, die das Passwort kennt, wird eine Maschine authentifiziert, auf welcher der private Schlüssel hinterlegt ist.
Die Nutzung von Git über SSH ist ausgesprochen praktisch. Einmal eingerichtet, erlaubt der SSH-Key dauerhaften Zugriff auf GitHub ohne weiteres Zutun. Auch andere Protokolle und Dienste profitieren von SSH-Keys für eine verschlüsselte Netzwerkverbindung. Neben Git mit SSH lässt sich das sichere SFTP-Protokoll zum Austausch von Dateien mit Servern einsetzen, ohne dass weitere Konfiguration vonnöten wäre.
Die Verbindung mit Git-Repositories erfolgt in der Regel von der Kommandozeile aus. Wurde ein SSH-Key eingerichtet, lässt sich problemlos ein Push auf ein eigenes Repository ausführen:
cd ./folder-with-git-repo/
git pushNeben der Anwendung auf der Kommandozeile profitieren auch GUI-Anwendungen von einem eingerichteten SSH-Schlüssel. Moderne FTP-Programme unterstützen das SSH Flie Transfer Protocol (SFTP). Dieses basiert auf SSH und greift auf vorhandene SSH-Schlüssel zurück
Wie nutzt man SSH-Keys mit GitHub
Um mit einem SSH-Key auf sein GitHub-Konto zuzugreifen, hinterlegt man den öffentlichen Schlüssel bei GitHub. Der private Schlüssel verbleibt auf dem eigenen Rechner. Über einen Abgleich der Schlüsseldaten wird die Entwicklungsmaschine gegenüber GitHub authentifiziert. Dies ermöglicht schreibenden Zugriff auf eigene Repositories. Diese Methode funktioniert auch mit GitHub-Alternativen wie Gitlab oder Bitbucket.
So praktisch SSH-Keys auch sind, muss man beim Umgang Vorsicht walten lassen. Geben Sie unter keinen Umständen den privaten Schlüssel weiter. Der private Schlüssel erlaubt u. U. einer anderen Partei, sich als man selbst auszugeben. In Ihrem Namen könnten sich Dritte auf einem Server einloggen oder Code in Repositories ändern.
Voraussetzungen für Nutzung von mit SSH-Key GitHub
Wir setzen hier voraus, dass Sie unter einer Linux-artigen Umgebung arbeiten. Dazu zählen Linux/Unix, macOS, sowie Windows mit installiertem WSL2. Ferner müssen die folgenden Bedingungen erfüllt sein:
- Git installiert
- SSH installiert
- GitHub-Konto angelegt
Überprüfen wir zunächst, ob die lokalen Voraussetzungen erfüllt sind. Mit dem folgenden Befehl testen wir, ob Git und SSH installiert sind. Sofern Sie keine Fehlermeldung „git not found“ oder „ssh not found“ erhalten, sind beide vorhanden:
which git ssh
Ferner legen wir das .ssh-Verzeichnis im Nutzerordner an, falls es noch nicht existiert:
mkdir -vp ~/.ssh/Wir erklären im Folgenden, wie Sie einen SSH-Key für die Nutzung von GitHub anlegen und registrieren. Ist dieser Schritt abgeschlossen, zeigen wir, wie Sie den öffentlichen SSH-Key bei GitHub hinterlegen und erklären den Zugriff auf Git-Repositories über SSH:
- SSH-Schlüsselpaar auf dem eigenen System anlegen
- Öffentlichen SSH-Key bei GitHub hinterlegen
- Mit SSH-Key auf GitHub-Repository zugreifen
SSH-Key auf dem eigenen System anlegen und registrieren
Als ersten Schritt werden wir ein öffentliches / privates SSH-Schlüsselpaar auf unserem lokalen System erzeugen. Kopieren Sie die dafür genutzten Befehle in der exakt gleichen Reihenfolge und führen Sie diese auf Ihrer Kommandozeile aus.
Wir halten uns hier an die offizielle Dokumentation von GitHub. Das Verfahren ändert sich von Zeit zu Zeit. Zum Beheben von SSH-Fehlern kann es also nicht schaden, dort nachzuschauen.
Zunächst starten wir den SSH-Key Generator, um für GitHub ein öffentliches / privates Schlüsselpaar zu erzeugen. Wir nutzen den ssh-keygen Befehl, welcher standardmäßig als Teil der OpenSSH-Installation auf dem System vorhanden ist:
Wir rufen ssh-keygen auf der Kommandozeile auf und übergeben drei Optionen:
- Option -f gefolgt von Pfad und Name des neuen Schlüssels
- Option -t gefolgt vom Namen des Algorithmus, in diesem Fall ed25519
- Option -C gefolgt von einer E-Mailadresse als Kommentar
ssh-keygen -f "$HOME/.ssh/github_id_ed25519" -t ed25519 -C "your_email@example.com"Sie können eine beliebige E-Mailadresse zur Erzeugung des Schlüsselpaars verwenden. Diese dient lediglich als Label; es muss sich nicht um dieselbe Adresse handeln, mit der Sie sich bei GitHub einloggen.
Der SSH keygen-Befehl fordert uns auf, eine „Passphrase“ (zu Deutsch „Passsatz“) für den privaten Schlüssel festzulegen. Anders als ein Passwort darf eine Passphrase Leerzeichen enthalten. Die Passphrase sollte mehrere Wörter lang sein und ist dann gleichermaßen besser zu merken und schwer zu erraten. Für erhöhte Sicherheit baut man einige Ziffern oder Sonderzeichen mit ein. Geben Sie die Passphrase ein und drücken Sie „Enter“. Wiederholen Sie den Prozess, um die Erstellung des SSH-Schlüsselpaars abzuschließen.
Wir nutzen für unser Schlüsselpaar den Ed25519-Algorithmus. Tatsächlich ist eine ganze Reihe an Algorithmen verfügbar. Wir stellen die Verschlüsselungsverfahren im Überblick in einem eigenen Artikel vor.
Bevor wir unseren frisch erzeugten SSH-Key mit GitHub nutzen können, führen wir einen weiteren Schritt durch. Dieser ist optional, wird jedoch dringend empfohlen. Wir fügen den privaten Schlüssel zum sogenannten „SSH-Agent“ hinzu. Dabei handelt es sich um ein Hintergrundprogramm, welches auf dem lokalen System läuft. Führen Sie den folgenden Befehl auf der Kommandozeile aus und geben Sie die Passphrase ein, wenn Sie danach gefragt werden:
- Windows / Linux
ssh-add ~/.ssh/github_id_ed25519- macOS bis 11 Big Sur
ssh-add -K ~/.ssh/github_id_ed25519- macOS ab 12 Monterey
ssh-add --apple-use-keychain ~/.ssh/github_id_ed25519Der SSH-Agent hat Zugriff auf hinzugefügte private Schlüssel und ermöglicht, diese für Verbindungen zu nutzen, ohne jedes Mal die Passphrase einzugeben. Doch der SSH-Agent kann noch mehr:
„ssh-agent is a program that can hold a user's private key, so that the private key passphrase only needs to be supplied once. A connection to the agent can also be forwarded when logging into a server, allowing SSH commands on the server to use the agent running on the user's desktop.“ — Quelle: https://www.ssh.com/academy/ssh/keygen#adding-the-key-to-ssh-agent
Übersetzung: „SSH-Agent ist ein Programm, welches private Schlüssel eines Nutzers vorhält, so dass die Passphrase nur einmal eingegeben werden muss. Eine Verbindung zum SSH-Agenten lässt sich beim Einloggen in einen Server weiterreichen. So können SSH-Befehle auf dem Server den SSHAgenten nutzen, welcher auf dem Arbeitsrechner des Nutzers läuft.“ (übersetzt von IONOS)
SSH-Key bei GitHub hinterlegen
Wir haben ein SSH-Keypair auf unserem lokalen System erzeugt. Damit steht eine Hälfte der verschlüsselten Kommunikation bei der Nutzung von Git über SSH. Der noch verbleibende Schritt besteht darin, den öffentlichen SSH-Key bei GitHub zu hinterlegen.
Nun benötigen wir den Inhalt des öffentlichen Schlüssels. Wechseln Sie zu Ihrer lokalen Kommandozeile und geben Sie den folgenden Befehl ein:
cat ~/.ssh/github_id_ed25519.pubVorsicht: der Dateiname eines öffentlichen Schlüssels endet in .pub für „Public Key“. Jedoch endet der private Schlüssel nicht etwa in .priv, oder dergleichen. Stattdessen hat der private Schlüssel keine Endung. Teilen Sie ausschließlich den Public Key-Key mit GitHub und sonstigen Dritten.
Mit SSH-Key auf GitHub-Repository zugreifen
Wir haben die Schlüssel lokal erzeugt und den öffentlichen SSH-Key auf GitHub hinterlegt. Testen wir zunächst, ob die Verbindung funktioniert. Wir bedienen uns des folgenden Befehls:
ssh -T git@github.comHandelt es sich um den ersten Verbindungsaufbau mit GitHub von dieser Maschine aus, werden Sie zusätzlich aufgefordert, den Server zu den „Known Hosts“ hinzuzufügen:
Beim Zugriff auf GitHub-Repositories unterscheiden wir zwischen lesendem und schreibendem Zugriff. Öffentliche Repositories lassen sich von jedermann auslesen; dazu wird keinerlei Authentifizierung, also auch kein SSH-Key benötigt.
Zum Herunterladen eines Repository als lokale Kopie nutzt man den git clone-Befehl. Wir zeigen das beispielshalber am Repository des beliebten Netzwerk-Tools cURL. Wir besuchen die GitHub-Seite des öffentliche cURL-Repository und kopieren die Clone-URL:
Mit der Clone-URL ausgestattet, wechseln wir zurück zur lokalen Kommandozeile. Wir erzeugen einen Beispielordner repo auf dem Desktop und wechseln zu diesem. Im Anschluss klonen wir das cURL-Repository, indem wir git clone mit der Clone-URL aufrufen:
cd ~/Desktop/
mkdir -p repo && cd repo
git clone https://github.com/curl/curl.git
Wir wechseln in den cURL Repository-Ordner und zeigen mit dem git status-Befehl den Zustand des Repository an:
cd ~/Desktop/repo/curl/
git status
Auch der git pull-Befehl, welcher ein Repository auf den neuesten Stand bringt, benötigt lediglich lesenden Zugriff. Wir führen Git-Pull im Repository-Ordner aus; prinzipiell funktioniert dies, auch wenn wahrscheinlich noch keine Änderungen vorhanden sind:
git pullNun versuchen wir, mit dem git push-Befehl auf das GitHub-Repository zu schreiben:
git push
Was passiert hier? Die zum Klonen des öffentlichen cURL-Repository verwendete Clone-URL beginnt mit HTTPS. Für unseren lokalen Klon ist dementsprechend als „Origin“ („Ursprung“) eine HTTPS-URL hinterlegt. Wir überprüfen das Origin mit dem git show-Befehl:
git remote -v show
Für lesenden Zugriff reicht eine HTTPS-URL, jedoch wird ein SSH-Key zum Schreiben auf GitHub-Repositories benötigt. Denn die Authentifizierung von Nutzerinnen und Nutzern per Username/Password wird auf GitHub seit August 2021 nicht mehr unterstützt.
Um Git-Push dennoch testen zu können, wenden wir einen Trick an. Zunächst erzeugen wir auf GitHub ein eigenes, leeres Repository:
Den Anweisungen auf GitHub folgend ändern wir auf unserem System die Push-URL des lokalen cURL-Klons, so dass unser leeres GitHub-Repository als Origin verwendet wird. Ferner setzen wir den Branch auf „main“. Im Anschluss führen wir den Git-Push aus; die Operation schließt erfolgreich ab und greift auf unseren vorher angelegten SSH-Key zurück, um uns gegenüber GitHub zu authentifizieren.
git remote set-url origin git@github.com:<user>/test.git</user>
git branch -M main
git push -u origin main
Mehrere SSH-Keys für verschiedene GitHub-Konten verwenden
Es ist problemlos möglich, nur einen SSH-Key für verschiedene GitHub- oder sonstige Konten zu verwenden. Erinnern wir uns: den öffentlichen Schlüssel können wir bedenkenlos teilen.
Technisch ist es durchaus möglich, eigene SSH-Keys für verschiedene Services und Sites zu nutzen. Es bieten sich zwei Methoden an:
- SSH-Befehl mit Parametern aufrufen
- SSH-Config-Datei anlegen
SSH-Befehle mit Parametern fallen unter Umständen sehr lang aus, weshalb wir diesen Ansatz hier nicht zeigen. Generell ist es komfortabler, mit einer SSH-Config-Datei zu arbeiten. Dies erfordert etwas mehr Aufwand bei der Konfiguration des eigenen Systems, dieser muss jedoch nur einmalig geleistet werden. Hier ein Überblick der an der SSH-Konfiguration beteiligten Ordner und Dateien:
| SSH-Konfiguration | Pfad | Erklärung |
|---|---|---|
| Config-Ordner | ~/.ssh/ | Enthält SSH-Konfiguration und Schlüsselpaare. |
| Private Key | ~/.ssh/key-name | Privater Schlüssel eines Schlüsselpaars. |
| Public Key | ~/.ssh/key-name.pub | Öffentlicher Schlüssel eines Schlüsselpaars. |
| Config-Datei | ~/.ssh/config | SSH-Konfigurationsdatei. |
| Known Hosts | ~/.ssh/known_hosts | Liste mit in der Vergangenheit verbundenen Hosts. |
Legen wir zunächst die SSH-Config-Datei an. Wir erzeugen die Datei, passen die Nutzerrechte an und öffnen sie im Kommandozeilen-Editor:
touch ~/.ssh/config
chmod 600 ~/.ssh/config
nano ~/.ssh/configAnschließend kopieren Sie den folgenden Block in den Editor und folgen Sie den Screenshots zum Speichern der Datei:
# Github
Host github github.com
HostName github.com
User git
IdentityFile "~/.ssh/github_id_ed25519"
IdentitiesOnly yes
Nach dem Einfügen des GitHub-Konfigurationsblocks lässt sich eine SSH-Verbindung unter Angabe des festgelegten Host-Kürzels github aufbauen:
ssh -T githubFügen Sie dem dargestellten Schema folgend Konfigurationsblöcke für weitere Dienste oder Konten in die SSH-Config-Datei ein. Hier die dabei zum Einsatz kommenden Parameter im Überblick:
| Einstellung | Erklärung | Beispiel |
|---|---|---|
| Host | Kann mehrere beliebige Namen enthalten. | github.com github |
| HostName | Hostname des entfernten Systems, auf dem SSH läuft; auch eine IP-Adresse lässt sich nutzen. | github.com |
| User | Git-Nutzer auf dem entfernten System; muss exakt übernommen werden. | git |
| IdentityFile | Absoluter Pfad zum privaten Schlüssel. Passen Sie diesen an, falls Sie mehrere Schlüssel verwenden. | ~/.ssh/github_id_ed25519 |
| IdentitiesOnly | Legt fest, dass für diesen Host der Zugriff nur per Schlüssel erfolgen darf. | yes |
Noch ein Tipp zum Abschluss. Falls Sie SSH-Konfigurationen für mehrere Hosts mit eigenen Schlüsseln anlegen, sollten Sie am Ende der Datei einen Block mit Einstellungen für nicht aufgeführte Hosts hinzufügen:
# For all hosts
Host *
IdentitiesOnly no
IgnoreUnknown UseKeychain, AddKeysToAgent
UseKeychain yes
AddKeysToAgent yesDies erlaubt Zugriff ohne SSH-Schlüssel auf nicht spezifizierte Hosts. So können Sie per SSH-Befehl mit ihrem Nutzernamen eine Verbindung zu einem Host aufbauen und das Passwort beim Verbindungsaufbau eingeben:
ssh user@hostOhne die Zeile „IdentitiesOnly no“ in der abschließenden Konfiguration probiert SSH nacheinander alle Schlüssel in ~./ssh/, um sich mit dem Server zu verbinden. Ist kein passender Schlüssel dabei, kommt es zum Fehler „Too many authentication failures“.