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.

Free VPS Trial
vServer kostenlos testen für 30 Tage

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 push
bash

Neben 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
bash
Test der Installation von Git und SSH
Auf unserem System sind Git und SSH installiert. Beispielshalber suchen wir nach einem nicht existierenden Befehl „unknown“.

Ferner legen wir das .ssh-Verzeichnis im Nutzerordner an, falls es noch nicht existiert:

mkdir -vp ~/.ssh/
bash

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:

  1. SSH-Schlüsselpaar auf dem eigenen System anlegen
  2. Öffentlichen SSH-Key bei GitHub hinterlegen
  3. 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"
bash
Hinweis

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.

Erzeugen eines SSH-Keypairs für GitHub
Wir haben den SSH-Key für die Nutzung mit GitHub erzeugt.
Tipp

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
bash
  • macOS bis 11 Big Sur
ssh-add -K ~/.ssh/github_id_ed25519
bash
  • macOS ab 12 Monterey
ssh-add --apple-use-keychain ~/.ssh/github_id_ed25519
bash

Der 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:

Zitat

„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.

Die Einstellungsseite des GitHub-Kontos
Loggen Sie sich in Ihr GitHub-Konto ein und navigieren Sie zur Schlüssel-Seite der Einstellungen.
GitHub-Einstellung zum Hinzufügen eines SSH-Schlüssels
Klicken Sie unter „SSH keys“ auf den Knopf „New SSH key“ und öffnen Sie damit die Seite zum Hinzufügen eines neuen Schlüssels.

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.pub
bash
Hinweis

Vorsicht: 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.

Inhalt des öffentlichen Schlüssels auf der Kommandozeile
Kopieren Sie den ausgegebenen öffentlichen Schlüssel und wechseln Sie zurück zur GitHub-Seite.
Öffentlicher SSH-Key in GitHub-Einstellungsseite kopiert
Fügen Sie den kopierten öffentlichen Schlüssel ein und vergeben Sie optional einen Titel. Speichern Sie die Änderungen mit einem Klick auf den Knopf „Add SSH key“.
Übersicht der hinzugefügten SSH-Keys in GitHub
Der neu hinzugefügte SSH-Key für GitHub wird Ihnen in der Schlüssel-Übersicht angezeigt.

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.com
bash

Handelt 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:

Hinzufügen des GitHub-Server zu den SSH Known-Hosts
Bestätigen Sie das Hinzufügen des Servers, indem Sie „yes“ eingeben und Enter drücken.

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:

Übersichtsseite des cURL-Repository
Der Code des cURL-Repository in der Übersicht. / Quelle: https://github.com/curl/curl
Clone-Url des cURL-Repository kopiert
Wir kopieren die „Clone-URL“ des cURL-Repository. / Quelle: https://github.com/curl/curl

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
bash
Klonen des cURL-Repository auf der lokalen Kommandozeile
Das geklonte cURL-Repository liegt nun im Ordner curl.

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
bash
Status des lokalen cURL-Repository
Der Aufruf von git status zeigt, dass der Zustand normal ist.

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 pull
bash

Nun versuchen wir, mit dem git push-Befehl auf das GitHub-Repository zu schreiben:

git push
bash
Ergebnis von Git-Pull und Git-Push des lokalen cURL-Repository
Git-Pull funktioniert; Git-Push schlägt fehl, da unsere Maschine nicht authentifiziert ist.

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
bash
Remotes des lokalen cURL-Repository auf der Kommandozeile
Die URLs für die Git-Operationen Fetch und Push werden angezeigt.

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:

Neues Repository auf GitHub erstellen
Wir erstellen ein neues Repository mit Namen „test“.
Übersicht eines leeren GitHub-Repository
Unser leeres GitHub-Repository enthält Anweisungen zum Befüllen mit Code.

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
bash
Ändern der Push-URL und Git-Push vom lokalen Repository
Der Git-Push funktioniert nach dem Ändern der Push-URL.

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:

  1. SSH-Befehl mit Parametern aufrufen
  2. 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/config
bash

Anschließ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
Einfügen der GitHub-Konfiguration in SSH-Config-Datei
Fügen Sie den Konfigurationsblock ein und drücken Sie Strg + X, um die Änderungen zu schreiben und den Editor zu schließen.
Schreiben der geänderten SSH-Config-Datei
Bestätigen Sie den Namen der Datei, indem Sie Enter drücken.
Bestätigen der Änderungen an der SSH Config-Datei
Bestätigen Sie das Schreiben der Änderungen, indem Sie Enter drücken.

Nach dem Einfügen des GitHub-Konfigurationsblocks lässt sich eine SSH-Verbindung unter Angabe des festgelegten Host-Kürzels github aufbauen:

ssh -T github
bash

Fü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 yes
bash

Dies 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@host
bash

Ohne 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“.

War dieser Artikel hilfreich?