SSH ist eine von zwei Mög­lich­kei­ten, dich bei GitHub aus­zu­wei­sen – und nicht die einzige. GitHub hat 2021 die Passwort-Au­then­ti­fi­zie­rung für Git-Vorgänge ab­ge­schafft, nicht aber HTTPS als Weg. Über HTTPS funk­tio­niert der Zugriff weiterhin, nur eben mit einem per­sön­li­chen Zu­griffsto­ken statt eines Passworts. Du hast also die Wahl zwischen zwei Verfahren: HTTPS mit Token oder SSH mit einem Schlüs­sel­paar. Dieser Artikel zeigt den SSH-Weg – und vor allem jene Stelle, an der es in der Praxis klemmt: Die Adress­form beim Klonen ent­schei­det darüber, worüber ein Klon später kom­mu­ni­ziert. Ein hin­ter­leg­ter Schlüssel allein ändert daran nichts.

Zu­sam­men­fas­sung

  • Zwei Wege zu GitHub: HTTPS mit Zu­griffsto­ken oder SSH mit Schlüs­sel­paar
  • Schlüs­sel­paar erzeugen mit ssh-keygen und dem Verfahren Ed25519
  • Hin­ter­legt wird aus­schließ­lich der öf­fent­li­che Teil
  • Die Adress­form beim Klonen legt den Über­tra­gungs­weg fest
  • Be­stehen­den Klon umstellen mit git remote set-url
  • Zwei Konten brauchen zwei Schlüs­sel­paa­re und einen Eintrag in ~/.ssh/config

Wann SSH sich lohnt

Beide Wege führen zum Ziel, sie un­ter­schei­den sich im Alltag aber spürbar. Ein Zu­griffsto­ken läuft ir­gend­wann ab und will erneuert werden. Für HTTPS gibt es Hilfs­pro­gram­me, die die Zu­gangs­da­ten zwi­schen­spei­chern, damit du sie nicht bei jedem Vorgang eintippst. GitHub empfiehlt für Token die fein ab­ge­stuf­te Variante, bei der du die Rechte einzeln festlegst.

Ein Schlüs­sel­paar ist dagegen einmal ein­ge­rich­tet und danach still. Keine Eingabe bei jedem Vorgang, kein Ab­lauf­da­tum, keine Er­neue­rung.

Merkmal HTTPS mit Token SSH mit Schlüs­sel­paar
Nachweis per­sön­li­ches Zu­griffsto­ken privater Schlüssel auf deinem Rechner
Gül­tig­keit läuft ab, Er­neue­rung nötig kein Ab­lauf­da­tum
Eingabe im Alltag je nach Hilfs­pro­gramm, das die Daten zwi­schen­spei­chert keine, sobald der Agent den Schlüssel hält
Rechte fein abgestuft fest­leg­bar am Konto hin­ter­leg­ter Schlüssel
Wei­ter­ver­wen­dung an GitHub gebunden derselbe Schlüssel auch für andere Dienste

Der letzte Punkt wiegt mehr, als er klingt. Derselbe Schlüssel öffnet dir auch den Zugang zu eigenen Servern, etwa zu einem Linux vServer. Wenn du einen solchen Server in Betrieb nimmst, lohnt sich danach ein Blick in Server absichern.

Fakt

Seit Oktober 2026 kann GitHub bei un­ge­wöhn­lich hohem Ver­kehrs­auf­kom­men auch für anonyme Abrufe öf­fent­li­cher Re­po­si­to­ries über HTTPS vor­über­ge­hend eine Anmeldung verlangen. Vorgänge über SSH sind davon aus­drück­lich nicht betroffen.

Schlüssel erzeugen

Ein Schlüs­sel­paar entsteht mit einem einzigen Befehl:

ssh-keygen -t ed25519 -C "deine@adresse.example"
bash

Die Option -t wählt das Verfahren. Ed25519 ist heute die Stan­dard­emp­feh­lung. Die Option -C hängt einen Kommentar an, meist eine Adresse als Be­zeich­nung. Dieser Kommentar dient nur als Etikett und muss nicht deine GitHub-Adresse sein. Mit -f legst du Pfad und Namen selbst fest, etwa -f ~/.ssh/github_ed25519.

Es entstehen zwei Dateien: der private Schlüssel ohne Endung und der öf­fent­li­che mit der Endung .pub. Ein öf­fent­li­cher Ed25519-Schlüssel beginnt mit ssh-ed25519 AAAAC3NzaC1lZDI1NTE5, der private mit -----BEGIN OPENSSH PRIVATE KEY-----. Allein daran erkennst du, welche Datei du vor dir hast.

Beim Erzeugen fragt der Befehl nach einer Pass­phra­se. Diese Pass­phra­se schützt den privaten Schlüssel auf der Platte und darf Leer­zei­chen enthalten. Der private Schlüssel wird niemals wei­ter­ge­ge­ben. Wer ihn hat, kann sich als die zu­ge­hö­ri­ge Person ausgeben.

Damit du die Pass­phra­se nicht bei jedem Vorgang erneut tippst, gibt es den SSH-Agenten. Das ist ein Hin­ter­grund­pro­gramm, das den ent­schlüs­sel­ten privaten Schlüssel vorhält, sodass die Pass­phra­se nur einmal je Sitzung nötig ist. Hin­zu­ge­fügt wird der Schlüssel mit ssh-add ~/.ssh/github_ed25519. Unter macOS ab Monterey lautet der Aufruf ssh-add --apple-use-keychain ~/.ssh/github_ed25519, damit der Schlüs­sel­bund die Pass­phra­se speichert.

Hinweis

Unter Windows ohne Linux-Umgebung gilt ein eigener Weg. Wie du dort ein Schlüs­sel­paar erzeugst und ver­wal­test, liest du in SSH-Key mit PuTTY.

Den öf­fent­li­chen Teil eintragen

Hin­ter­legt wird aus­schließ­lich der öf­fent­li­che Schlüssel. Seinen Inhalt zeigt dir:

cat ~/.ssh/github_ed25519.pub
bash

Diese eine Zeile trägst du in den Ein­stel­lun­gen deines Kontos im Bereich für SSH- und GPG-Schlüssel ein. Ob die Ober­flä­che dort gerade so oder anders aussieht, spielt keine Rolle – der Weg führt immer über die Kon­to­ein­stel­lun­gen.

Danach prüfst du die Ver­bin­dung:

ssh -T git@github.com
bash

Beim ersten Ver­bin­dungs­auf­bau fragt SSH, ob der Server in die Liste der bekannten Hosts auf­ge­nom­men werden soll. Das be­stä­tigst du einmal, danach taucht die Frage nicht mehr auf.

Dateien im SSH-Ver­zeich­nis

Alles, was mit Schlüs­seln zu tun hat, liegt in einem einzigen Ver­zeich­nis. Diese Übersicht hilft, wenn du später suchst:

Pfad Inhalt
~/.ssh/ Ver­zeich­nis für Schlüssel und Kon­fi­gu­ra­ti­on
~/.ssh/name privater Schlüssel, ohne Endung
~/.ssh/name.pub öf­fent­li­cher Schlüssel
~/.ssh/config Zuordnung von Kürzeln zu Zielen und Schlüs­seln
~/.ssh/known_hosts bereits be­stä­tig­te Ge­gen­stel­len

Die Kon­fi­gu­ra­ti­ons­da­tei braucht ein­ge­schränk­te Rechte. Gesetzt werden sie mit chmod 600 ~/.ssh/config.

Klonen, ziehen, pushen

Hier liegt der Kern. Ein Re­po­si­to­ry lässt sich über zwei ver­schie­de­ne Adress­for­men an­spre­chen, und die Form, mit der du klonst, ent­schei­det dauerhaft darüber, worüber dieser Klon kom­mu­ni­ziert:

  • HTTPS-Form: https://github.com/benutzer/projekt.git
  • SSH-Form: git@github.com:benutzer/projekt.git

Wer mit https://github.com/... klont, kom­mu­ni­ziert über HTTPS. Das bleibt auch dann so, wenn im Konto längst ein Schlüssel hin­ter­legt ist. Der Schlüssel wird in diesem Fall schlicht nicht gefragt. Für SSH brauchst du die zweite Form:

git clone git@github.com:benutzer/projekt.git
bash

Auf GitHub lässt sich die Adress­form auf der Pro­jekt­sei­te um­schal­ten, bevor du sie kopierst. Ein Blick darauf erspart dir die ganze Feh­ler­su­che.

Be­stehen­den Klon umhängen

Für ein Projekt, das schon auf der Platte liegt, braucht es keinen neuen Klon. Welche Adresse im Einsatz ist, zeigt git remote -v. Um­ge­stellt wird mit:

git remote set-url origin git@github.com:benutzer/projekt.git
bash

Danach laufen git pull und git push über SSH, ohne weitere Eingabe.

Info

Lesender Zugriff auf öf­fent­li­che Re­po­si­to­ries braucht überhaupt keine Anmeldung. Der Schlüssel wird erst beim Schreiben gebraucht oder bei privaten Re­po­si­to­ries.

Von null zum ersten Push

Der voll­stän­di­ge Ablauf in sieben Schritten:

  1. Schlüs­sel­paar erzeugen mit ssh-keygen -t ed25519 -C "deine@adresse.example", den Pfad bei Bedarf über -f ~/.ssh/github_ed25519 festlegen.
  2. Eine Pass­phra­se vergeben, wenn der Befehl danach fragt.
  3. Den privaten Schlüssel dem Agenten übergeben mit ssh-add ~/.ssh/github_ed25519.
  4. Den öf­fent­li­chen Teil mit cat ~/.ssh/github_ed25519.pub anzeigen und in den Kon­to­ein­stel­lun­gen eintragen.
  5. Die Ver­bin­dung testen mit ssh -T git@github.com und die Ge­gen­stel­le einmalig be­stä­ti­gen.
  6. Das Projekt in der SSH-Form klonen mit git clone git@github.com:benutzer/projekt.git, oder einen vor­han­de­nen Klon mit git remote set-url umhängen.
  7. Än­de­run­gen mit git push hochladen – ohne Passwort, ohne Token.

Zwei Konten ne­ben­ein­an­der

Einen öf­fent­li­chen Schlüssel kannst du be­den­ken­los bei mehreren Diensten hin­ter­le­gen. GitHub nimmt denselben öf­fent­li­chen Schlüssel al­ler­dings nicht in zwei Konten an: Der Versuch endet mit der Meldung Key is already in use. Wer ein be­ruf­li­ches und ein privates Konto getrennt halten will, braucht deshalb zwei Schlüs­sel­paa­re und eine Zuordnung über die Kon­fi­gu­ra­ti­ons­da­tei unter ~/.ssh/config.

Ein Eintrag besteht aus Host als frei gewähltem Kürzel, HostName als tat­säch­li­chem Ziel, User git, IdentityFile mit dem Pfad zum privaten Schlüssel und IdentitiesOnly yes:

Host git-arbeit
    HostName github.com
    User git
    IdentityFile ~/.ssh/github_ed25519
    IdentitiesOnly yes
text

IdentitiesOnly yes sorgt dafür, dass nur der an­ge­ge­be­ne Schlüssel probiert wird. Ohne diese Ein­stel­lung probiert SSH der Reihe nach alle vor­han­de­nen Schlüssel durch und scheitert nach einigen Versuchen mit der Meldung Too many authentication failures.

Über das Kürzel lässt sich dann klonen:

git clone git-arbeit:benutzer/projekt.git
bash

Das Kürzel tritt damit an die Stelle von git@github.com. Für jedes weitere Konto legst du einen zweiten Block mit eigenem Kürzel und eigenem IdentityFile an.

Damit sind beide Fragen be­ant­wor­tet, die hinter dem Thema stecken. SSH ist für GitHub kein Muss, sondern die bequemere der beiden Mög­lich­kei­ten – ohne Ab­lauf­da­tum und ohne Eingabe bei jedem Vorgang. Ent­schei­dend ist dabei nicht der Schlüssel allein, sondern die Adresse: Ein Klon über https://github.com/... bleibt bei HTTPS, ganz gleich was im Konto hin­ter­legt ist. Wer git remote -v liest und bei Bedarf git remote set-url setzt, hat den häu­figs­ten Stol­per­stein hinter sich. Alles Weitere erledigt der Agent im Hin­ter­grund, und derselbe Schlüssel trägt dich an­schlie­ßend auch zu deinen eigenen Servern.

Zum Hauptmenü