GPG (GNU Privacy Guard) ermöglicht es dir, Dateien zu verschlüsseln, Dokumente zu signieren, die Echtheit von Software zu prüfen und deine Identität in Git-Commits nachzuweisen — alles mit Public-Key-Kryptografie, ohne ein gemeinsames Geheimpasswort austauschen zu müssen. Wenn du eine verschlüsselte Datei sendest, kann nur der vorgesehene Empfänger mit seinem privaten Schlüssel sie entschlüsseln. Wenn du einen Git-Commit signierst, kann jeder prüfen, dass du ihn verfasst hast und der Code nicht manipuliert wurde. Dieser Leitfaden behandelt praktische GPG-Nutzung von der Schlüsselerzeugung bis hin zu Alltagsworkflows für Dateiverschlüsselung, digitale Signaturen und Git-Integration.

Voraussetzungen

  • Ein Linux-, macOS- oder Windows-System
  • GnuPG 2.2 oder neuer installiert (prüfen mit gpg --version)
  • Ein Terminal oder eine Eingabeaufforderung
  • Eine E-Mail-Adresse für deine Schlüsselidentität

GnuPG installieren

# Debian / Ubuntu (meist vorinstalliert)
sudo apt install gnupg

# RHEL / Fedora
sudo dnf install gnupg2

# macOS
brew install gnupg

# Installation überprüfen
gpg --version
# gpg (GnuPG) 2.4.x

Dein Schlüsselpaar erzeugen

# Interaktive Schlüsselerzeugung mit allen Optionen
gpg --full-generate-key

Auf die Abfragen reagierst du folgendermaßen:

  1. Schlüsseltyp: Wähle ECC (sign and encrypt) oder RSA and RSA für maximale Kompatibilität
  2. Schlüsselgröße: 4096 für RSA oder Curve 25519 für ECC
  3. Ablaufdatum: Setze 1–2 Jahre (kann später verlängert werden). Erstelle niemals Schlüssel ohne Ablaufdatum
  4. Name und E-Mail: Verwende dieselbe E-Mail wie in deinem Git- und GitHub-Konto
  5. Passphrase: Wähle eine starke Passphrase — sie schützt deinen privaten Schlüssel, falls die Datei gestohlen wird
# Schlüssel auflisten
gpg --list-keys
gpg --list-secret-keys --keyid-format long

# Beispielausgabe:
# sec   ed25519/ABC123DEF456 2025-12-12 [SC] [expires: 2027-12-12]
#       ABCDEF1234567890ABCDEF1234567890ABC123DE
# uid           [ultimate] Your Name <you@example.com>
# ssb   cv25519/789GHI012JKL 2025-12-12 [E] [expires: 2027-12-12]

Die Schlüssel-ID (ABC123DEF456 in diesem Beispiel) verwendest du, um deinen Schlüssel in Befehlen zu referenzieren.

Widerrufszertifikat erzeugen

Tu das unmittelbar nach der Schlüsselerzeugung — bevor du es brauchst:

gpg --gen-revoke --output revoke-cert.asc ABC123DEF456

Speichere diese Datei sicher offline (USB-Stick, ausgedrucktes Papier). Falls dein Schlüssel kompromittiert wird, veröffentlichst du dieses Zertifikat, um ihn zu widerrufen.

Dateien verschlüsseln und entschlüsseln

Asymmetrische Verschlüsselung für einen Empfänger

# Zuerst den öffentlichen Schlüssel des Empfängers importieren
gpg --import colleague-pubkey.asc

# Eine Datei für einen bestimmten Empfänger verschlüsseln
gpg --encrypt --recipient colleague@example.com secret-report.pdf
# Erstellt: secret-report.pdf.gpg

# Für mehrere Empfänger verschlüsseln
gpg --encrypt --recipient alice@example.com --recipient bob@example.com data.tar.gz

# Verschlüsseln und signieren (empfohlen — beweist den Absender)
gpg --encrypt --sign --recipient colleague@example.com secret-report.pdf

# Mit ASCII-Armor verschlüsseln (textsichere Ausgabe für E-Mail)
gpg --encrypt --armor --recipient colleague@example.com message.txt
# Erstellt: message.txt.asc (base64-kodiert, e-mail-sicher)

Eine Datei entschlüsseln

# Entschlüsseln (GPG verwendet automatisch deinen privaten Schlüssel)
gpg --decrypt secret-report.pdf.gpg > secret-report.pdf

# Entschlüsseln und Signatur prüfen
gpg --decrypt signed-encrypted-file.gpg
# Ausgabe enthält: "Good signature from ..."

Symmetrische Verschlüsselung (passwortbasiert)

Wenn du keinen öffentlichen Schlüssel des Empfängers hast, nutze ein gemeinsames Passwort:

# Mit einer Passphrase verschlüsseln (kein Schlüssel erforderlich)
gpg --symmetric --cipher-algo AES256 backup.tar.gz
# Fordert eine Passphrase an
# Erstellt: backup.tar.gz.gpg

# Entschlüsseln
gpg --decrypt backup.tar.gz.gpg > backup.tar.gz

Dateien und Nachrichten signieren

Digitale Signaturen beweisen Authentizität (wer signiert hat) und Integrität (der Inhalt wurde nicht verändert).

# Eine losgelöste Signatur erstellen (separate .sig-Datei)
gpg --detach-sign release-v1.0.tar.gz
# Erstellt: release-v1.0.tar.gz.sig

# Eine losgelöste Signatur verifizieren
gpg --verify release-v1.0.tar.gz.sig release-v1.0.tar.gz
# Good signature from "Your Name <you@example.com>"

# Eine Klartext-Signatur erstellen (menschenlesbar)
gpg --clearsign announcement.txt
# Erstellt: announcement.txt.asc (Text mit eingebetteter Signatur)

# Eine Klartext-Signatur verifizieren
gpg --verify announcement.txt.asc

Git-Commits signieren

Signierte Commits zeigen auf GitHub und GitLab ein “Verified”-Badge und belegen, dass du den Commit erstellt hast.

Einrichtung

# Deine GPG-Schlüssel-ID ermitteln
gpg --list-secret-keys --keyid-format long
# sec   ed25519/ABC123DEF456 2025-12-12 [SC]

# Git für die Verwendung deines Schlüssels konfigurieren
git config --global user.signingkey ABC123DEF456

# Automatisches Signieren für alle Commits aktivieren
git config --global commit.gpgsign true

# Tags ebenfalls signieren
git config --global tag.gpgsign true

# Falls GPG-Abfragen fehlschlagen, TTY setzen
export GPG_TTY=$(tty)
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Deinen öffentlichen Schlüssel auf GitHub/GitLab exportieren

# Öffentlichen Schlüssel im ASCII-Format exportieren
gpg --export --armor ABC123DEF456

# Die Ausgabe kopieren (einschließlich -----BEGIN PGP PUBLIC KEY BLOCK-----)
# Auf GitHub einfügen: Settings > SSH and GPG keys > New GPG key

Signieren in der Praxis

# Einen einzelnen Commit signieren
git commit -S -m "Fix authentication bug"

# Signaturen im Log anzeigen
git log --show-signature -3

# Einen Tag signieren
git tag -s v1.0 -m "Release 1.0"

# Einen signierten Tag verifizieren
git tag -v v1.0

Verschlüsselungstools im Vergleich

MerkmalGPG (GnuPG)ageOpenSSLSignal Protocol
AnwendungsfallDateien, E-Mail, GitDateiverschlüsselungTLS, Zertifikate, DateienMessaging
SchlüsselverwaltungKeyring, Key-ServerEinfache SchlüsseldateienZertifikate, CAsAutomatisch
KomplexitätHoch (viele Optionen)Sehr geringMittelIn Apps integriert
Asymmetrische VerschlüsselungJa (RSA, ECC)Ja (X25519)JaJa
Digitale SignaturenJaNeinJaJa
Git-IntegrationNativNeinNeinNein
Am besten fürE-Mail, Git, PaketsignierungEinfache DateiverschlüsselungTLS/ServersicherheitChat-Anwendungen

Verwende GPG für Git-Commit-Signierung, E-Mail-Verschlüsselung und die Prüfung von Software-Paketen. Verwende age, wenn du eine einfache Dateiverschlüsselung ohne den Aufwand der Schlüsselverwaltung benötigst. Verwende OpenSSL für TLS-Zertifikate und serverseitige Verschlüsselung.

Best Practices für die Schlüsselverwaltung

# Privaten Schlüssel für Backup exportieren (offline aufbewahren!)
gpg --export-secret-keys --armor ABC123DEF456 > private-key-backup.asc

# Öffentlichen Schlüssel exportieren
gpg --export --armor ABC123DEF456 > public-key.asc

# Einen Schlüssel aus einer Datei importieren
gpg --import someone-public-key.asc

# Von einem Key-Server importieren
gpg --keyserver keyserver.ubuntu.com --recv-keys THEIR_KEY_ID

# Deinen Schlüssel auf einen Key-Server hochladen
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

# Ablaufdatum verlängern, bevor es abläuft
gpg --edit-key ABC123DEF456
# gpg> expire
# (neues Ablaufdatum setzen)
# gpg> save

# Einen kompromittierten Schlüssel widerrufen
gpg --import revoke-cert.asc
gpg --keyserver keyserver.ubuntu.com --send-keys ABC123DEF456

Fallstricke und Sonderfälle

Abgelaufene Schlüssel können weder verschlüsseln noch signieren: Wenn dein Schlüssel abläuft, kannst du keine neuen Signaturen erstellen oder Daten für Empfänger verschlüsseln. Alte Daten kannst du noch entschlüsseln und das Ablaufdatum rückwirkend verlängern. Verlängere immer vor dem Ablauf.

Verwirrung beim Trust-Modell: Der Import eines öffentlichen Schlüssels bedeutet nicht, dass du ihm vertraust. GPG kennzeichnet nicht vertraute Schlüssel mit einer Warnung. Verwende gpg --edit-key IHRE_ID und trust, um die Vertrauensstufe festzulegen, oder signiere den Schlüssel mit lsign, nachdem du die Identität verifiziert hast.

SSH-Agent vs. GPG-Agent: GPG hat einen eigenen Agent (gpg-agent), der deine Passphrase zwischenspeichert. Wenn du zusätzlich einen SSH-Agent verwendest, können sich beide gegenseitig stören. Modernes GPG kann auch als SSH-Agent dienen — konfiguriere dies in ~/.gnupg/gpg-agent.conf mit enable-ssh-support.

GUI-Passwortabfragen in headless Sitzungen: Wenn GPG über SSH oder in Skripten ausgeführt wird, kann das Pinentry-Programm fehlschlagen, weil keine grafische Oberfläche vorhanden ist. Setze GPG_TTY=$(tty) und konfiguriere pinentry-curses in ~/.gnupg/gpg-agent.conf:

echo "pinentry-program /usr/bin/pinentry-curses" >> ~/.gnupg/gpg-agent.conf
gpgconf --kill gpg-agent

Verschlüsselung großer Dateien ist langsam: GPG ist nicht für die Verschlüsselung von Dateien im Gigabyte-Bereich ausgelegt. Für große Datenmengen verschlüssele mit einem symmetrischen Verfahren (AES256) und schütze die Passphrase mit GPG, oder verwende Tools wie age, die für die Dateiverschlüsselung optimiert sind.

Fehlerbehebung

”gpg: signing failed: No secret key"

# Prüfen, ob die Signing-Key-ID mit der Git-Konfiguration übereinstimmt
git config --global user.signingkey
gpg --list-secret-keys --keyid-format long

# Sicherstellen, dass die E-Mail im GPG-Schlüssel mit der Git-E-Mail übereinstimmt
git config --global user.email

"gpg: decryption failed: No secret key”

# Du benötigst den privaten Schlüssel, der zum Verschlüsselungsempfänger passt
gpg --list-secret-keys

# Falls der Schlüssel auf einem anderen Rechner liegt, exportieren und importieren
# Auf dem Quellrechner:
gpg --export-secret-keys --armor KEYID > key.asc
# Auf dem Zielrechner:
gpg --import key.asc

Git-Commit-Signierung hängt sich auf

# Der GPG-Agent kann keine Passphrase abfragen
export GPG_TTY=$(tty)

# GPG-Signierung direkt testen
echo "test" | gpg --clearsign

# Bei VS Code oder einer IDE den TTY im Shell-Profil konfigurieren
echo 'export GPG_TTY=$(tty)' >> ~/.bashrc

Zusammenfassung

  • GPG verwendet Public-Key-Kryptografie, bei der dein öffentlicher Schlüssel Daten verschlüsselt und dein privater Schlüssel sie entschlüsselt — öffentliche Schlüssel darf jeder kennen, private Schlüssel müssen absolut geschützt bleiben
  • Schlüssel erzeugen mit gpg --full-generate-key und unmittelbar danach ein offline gespeichertes Widerrufszertifikat für Notfälle erstellen
  • Dateien verschlüsseln mit gpg --encrypt --recipient für asymmetrische Verschlüsselung oder gpg --symmetric, wenn eine gemeinsame Passphrase praktischer ist
  • Git-Commits signieren mit git commit -S und commit.gpgsign true für automatisches Signieren konfigurieren — öffentlichen Schlüssel zu GitHub hinzufügen für “Verified”-Badges
  • Ablaufdaten für Schlüssel setzen und vor dem Ablauf verlängern — ein abgelaufener Schlüssel blockiert Verschlüsselung und Signierung, kann aber noch alte Daten entschlüsseln
  • Privaten Schlüssel offline sichern — sein Verlust bedeutet den dauerhaften Verlust der Entschlüsselungsmöglichkeit für alle damit verschlüsselten Daten

Verwandte Artikel