TL;DR: Git prüft standardmäßig nicht, ob ein Commit wirklich von der Person stammt, die im Author-Feld steht. Mit GPG- oder SSH-Signaturen kannst du deine Commits kryptografisch signieren und so deine Identität verifizieren. GitHub zeigt dann ein grünes "Verified"-Badge an.

🤔 Warum solltest du deine Commits signieren?

Hast du schon mal darüber nachgedacht, dass jeder in Git unter einem beliebigen Namen committen kann? Ein einfaches git config user.name "Linus Torvalds" reicht aus, und schon sehen deine Commits so aus, als kämen sie vom Linux-Erfinder persönlich. Das ist kein Bug – Git wurde als dezentrales System entworfen und vertraut erstmal niemandem.

Genau hier kommt Commit Signing ins Spiel. Durch das Signieren deiner Commits beweist du kryptografisch, dass ein Commit wirklich von dir stammt. Plattformen wie GitHub, GitLab und Bitbucket zeigen dann ein "Verified"-Badge neben deinen Commits an.

Falls du noch mal die Grundlagen von Git auffrischen willst, schau dir diesen Artikel an:

Git: Die Geschichte, Anwendung und Vorteile der Quellcodeverwaltung

Erfahre alles über Git - von der Geschichte über die Anwendung bis hin zu den Vorteilen der weltweit beliebtesten Quellcodeverwaltung.

Disane.dev

🔐 Was ist Commit Signing? GPG vs. SSH

Es gibt zwei Methoden, um deine Commits zu signieren:

GPG-Signierung (klassisch)

GPG (GNU Privacy Guard) ist der Klassiker. Es verwendet ein asymmetrisches Schlüsselpaar (öffentlicher + privater Schlüssel), um Commits kryptografisch zu signieren. GPG wird seit Jahren für E-Mail-Verschlüsselung und Softwarepakete verwendet und ist sehr ausgereift.

SSH-Signierung (modern)

Seit Git 2.34 kannst du auch SSH-Schlüssel zum Signieren verwenden. Wenn du bereits einen SSH-Key für GitHub nutzt, kannst du denselben Schlüssel auch zum Signieren verwenden. Das ist einfacher einzurichten, da kein separates Tool nötig ist.

🛠️ GPG-Signierung einrichten

Schritt 1: GPG installieren

Je nach Betriebssystem installierst du GPG unterschiedlich:

# Linux (Debian/Ubuntu)
sudo apt-get install gnupg

# macOS
brew install gpg

# Windows
# Lade Gpg4win herunter: https://www.gpg4win.org/

Schritt 2: GPG-Schlüssel generieren

Erstelle einen neuen GPG-Schlüssel mit folgendem Befehl:

gpg --full-generate-key

Wähle bei den Optionen:

• Schlüsseltyp: RSA and RSA (Standard)
• Schlüssellänge: 4096 Bit (maximale Sicherheit)
• Gültigkeitsdauer: Je nach Vorliebe (z.B. 1 Jahr oder unbegrenzt)
• E-Mail-Adresse: Muss mit deiner GitHub-E-Mail übereinstimmen!

Schritt 3: Schlüssel-ID herausfinden

Liste deine geheimen Schlüssel auf:

gpg --list-secret-keys --keyid-format=long

Die Ausgabe sieht etwa so aus:

sec   rsa4096/3AA5C34371567BD2 2024-01-15 [SC]
      ABCDEF1234567890ABCDEF1234567890ABCDEF12
uid                 [ultimate] Max Mustermann <[email protected]>
ssb   rsa4096/42B317FD4BA89E7A 2024-01-15 [E]

Deine Key-ID ist in diesem Beispiel 3AA5C34371567BD2 (der Teil nach rsa4096/).

Schritt 4: Öffentlichen Schlüssel exportieren

gpg --armor --export 3AA5C34371567BD2

Kopiere die gesamte Ausgabe (inklusive -----BEGIN PGP PUBLIC KEY BLOCK----- und -----END PGP PUBLIC KEY BLOCK-----).

Schritt 5: Schlüssel zu GitHub hinzufügen

1. Gehe zu GitHub Settings → SSH and GPG keys
2. Klicke auf "New GPG key"
3. Füge den exportierten öffentlichen Schlüssel ein
4. Klicke auf "Add GPG key"

Schritt 6: Git konfigurieren

Sage Git, welchen Schlüssel es verwenden soll und aktiviere das automatische Signieren:

# Signing-Key setzen
git config --global user.signingkey 3AA5C34371567BD2

# Automatisches Signieren aktivieren
git config --global commit.gpgsign true

# Optional: Auch Tags automatisch signieren
git config --global tag.gpgsign true

Ab jetzt werden alle deine Commits automatisch signiert! 🎉

🔑 SSH-Signierung einrichten (die einfachere Alternative)

Wenn du bereits einen SSH-Key hast, ist die SSH-Signierung deutlich schneller eingerichtet.

Schritt 1: Git auf SSH-Signierung umstellen

# SSH als Signaturformat setzen
git config --global gpg.format ssh

# Deinen SSH-Schlüssel als Signing-Key setzen
git config --global user.signingkey ~/.ssh/id_ed25519.pub

# Automatisches Signieren aktivieren
git config --global commit.gpgsign true

Schritt 2: SSH-Key zu GitHub hinzufügen

Wichtig: Du musst deinen SSH-Key als Signing Key hinzufügen (nicht nur als Authentication Key):

1. Gehe zu GitHub Settings → SSH and GPG keys
2. Klicke auf "New SSH key"
3. Wähle als Key type: "Signing Key"
4. Füge deinen öffentlichen SSH-Schlüssel ein

Falls du noch keinen SSH-Schlüssel hast, erstelle einen mit:

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

Wenn du dich intensiver mit Versionierung und semantischen Tags beschäftigst, könnte dich auch dieses Thema interessieren:

Semantic Versioning: Ein Leitfaden für Entwickler

Erfahre alles über Semantic Versioning (SemVer) - den Standard für Versionsnummern in der Softwareentwicklung.

Disane.dev

✅ Signierte Commits überprüfen

Lokal verifizieren

Prüfe die Signatur deiner Commits mit:

# Einzelnen Commit verifizieren
git verify-commit HEAD

# Signatur im Log anzeigen
git log --show-signature -1

# Kompakte Ansicht mit Signatur-Status
git log --pretty="format:%h %G? %aN %s" -5

Die Signatur-Indikatoren bedeuten:

• G = Gültige Signatur (Good)
• B = Ungültige Signatur (Bad)
• U = Gültig, aber nicht vertrauenswürdig (Untrusted)
• N = Keine Signatur (None)

Auf GitHub

Auf GitHub siehst du neben signierten Commits ein grünes "Verified"-Badge. Klickst du darauf, zeigt GitHub Details zur Signatur an – inklusive der verwendeten Key-ID und der zugehörigen E-Mail-Adresse.

🔧 Troubleshooting: Häufige Probleme

GPG-Agent startet nicht

Falls du die Fehlermeldung gpg: signing failed: No secret key bekommst:

# GPG-Agent neu starten
gpgconf --kill gpg-agent
gpgconf --launch gpg-agent

# Prüfe, ob der richtige Key konfiguriert ist
git config --global user.signingkey

Pinentry-Problem (kein Passwort-Dialog)

Auf manchen Systemen (besonders in WSL oder headless Servern) fehlt ein Pinentry-Programm:

# Pinentry für Terminal setzen
echo "pinentry-program /usr/bin/pinentry-tty" >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent

Auf macOS empfiehlt sich:

brew install pinentry-mac
echo "pinentry-program $(which pinentry-mac)" >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent

E-Mail stimmt nicht überein

Die E-Mail in deinem GPG-Schlüssel muss mit der E-Mail in deinen GitHub-Einstellungen übereinstimmen. Prüfe das mit:

# E-Mail im GPG-Key
gpg --list-secret-keys --keyid-format=long

# E-Mail in Git
git config user.email

GPG-Programm nicht gefunden

Auf manchen Systemen musst du Git explizit sagen, wo GPG liegt:

# Linux/macOS
git config --global gpg.program gpg

# Windows (Gpg4win)
git config --global gpg.program "C:/Program Files (x86)/GnuPG/bin/gpg.exe"

🏁 Fazit

Das Signieren von Git Commits ist ein wichtiger Schritt für mehr Sicherheit und Vertrauenswürdigkeit in deinen Projekten. Ob du dich für GPG (ausgereift und weit verbreitet) oder SSH (einfacher und moderner) entscheidest – beide Methoden erfüllen ihren Zweck.

Mit nur wenigen Befehlen hast du das Setup erledigt und ab dann werden alle deine Commits automatisch signiert. Deine Teammitglieder und die Open-Source-Community können dann sicher sein, dass deine Commits wirklich von dir stammen.

Meine Empfehlung: Wenn du bereits SSH-Keys nutzt, nimm die SSH-Signierung – es ist der einfachste Weg. Für maximale Kompatibilität und wenn du in einem Unternehmen arbeitest, ist GPG die bessere Wahl.